Class to take any subclass of Base

Question

I reckon this is a simple question, but so is my C++ knowledge.

I have a class named Learner:

template <class T>
class Learner {
 T* _someRef;
 (...)
}

And a base class from which objects inherit.

My idea is to have the Learner accept any objects which subclass Base, e.g. Base1, Base2, etc. I can assert the type using c++ 11's type_traits. Problem is, I am required to provide template specialization for each of the Base extensions, e.g.:

template Learner<T>::Learner(...) { //implementation };
// However I am required to declare template-specifications for each Base
// derived type, else I'll get compiler errors. This seems useless as
// the generic-inplementation will still be called, but requires me to
// specify a declaration for each Base extension.What if I have n Base
// extensions, makes no sense to do this for 50 Base extensions.
template Learner<Base1>::Learner(...);
template Learner<Base2>::Learner(...);

Which partly defeats the purpose of what I'm trying to achieve, as the operations will then be the same for every class since well, they all implement Base's virtual functions. How can I achieve this? Making n template specifications doesn't seem right... It works fine for a small number of extensions, but for larger numbers if its just intractable.

Answer 1

If I understand your question, I think what you're looking for is static_assert:

template<typename T>
struct Foo {
   static_assert(is_base_of<Base, T>::value, "T must inherit from Base");
};

For C++11, you're required to provide a message:

http://en.cppreference.com/w/cpp/language/static_assert

Also, you have more options on compile time checks, if need be, using type_traits:

http://en.cppreference.com/w/cpp/language/static_assert

Answer 2

Apart from the static_assert(...) to help fix the problem with the virtual inheritance you can use the keyword override in the derived classes as such:

class Base {
public:
    virtual doSomething() = 0; // purely virtual
};

class DerivedA : public Base {
public:
    virtual doSomething() override;
};

class DerivedB : public Base {
public:
    virtual doSomething() override;
};

This way it should help to avoid any ambiguity.

Edit

I'm adding this section to see if it helps the OP:

template <class T>
class Learner {
    T* _someRef;

public:
    Learner() { _someRef = new T(); }

    ~Learner() {
        if ( _someRef != nullptr ) {
           delete _someRef;
           _someRef = nullptr;
        }
    }

    void caller() {
        _someRef->doSomething();
    }
};

class Base {
public:
    virtual void doSomething() = 0;
};

class D1 : public Base {
public:
    virtual void doSomething() override {
        std::cout << "D1's doSomething was called" << std::endl;
    }
};

class D2 : public Base {
public:
    virtual void doSomething() override {
        std::cout << "D2's doSomething was called" << std::endl;
    }
};

int main() {
    Learner<D1> ld1;
    Learner<D2> ld2;
    ld1.caller();
    ld2.caller();

    _getch();
    return 0;
}

Here I didn't have to use any specializations. Now this pattern will probably only work with complete types as well as those that are default constructible. If they are not complete or default constructible that is where you will probably need to use specialization. For example:

Now let's see where specialization comes into play let's add a 3rd class with a non default constructor.

class D3 : public Base {
private:
    unsigned int _x;
public:
    explicit D3( unsigned int x ) : _x( x ) {}

    virtual void doSomething() override {
        std::cout << "D3's doSomething was called: constructed with " << _x << std::endl;
    }
};

If we were to try and do this:

{
    Learner<D3> ld3; // compiler error
    Learner<D3> ld3( 5 ); // compiler error
    Learner<D3> ld3( D3( 5 ) ); // compiler error
    D3 d3(5);
    Learnder<D3> ld3( d3 ); // compiler error
}

None of the above will work. So we HAVE to specialize as such:

template<>
class Learner<D3> {
private:
    D3* _d3;
public:
    explicit Learner( unsigned int x ) {
        _d3 = new D3( x );
    }

    explicit Learner( D3 d3 ) {
        _d3 = new D3( d3 );
    }

    ~Learner() {
        if ( _d3 != nullptr ) {
            delete _d3;
            _d3 = nullptr;
        }
    }

    void caller() {
        _d3->doSomething();
    }
};

With this specialization I chose to add 2 constructors to this version of Learner<T>. One for accepting a parameter to be able to construct a D3 object and one that takes a D3 object; now we can easily do this:

{    
Learner<D3> ld3a( 7 );
ld3a.caller();
D3 d3( 5 );
Learner<D3> ld3b( d3 );
ld3b.caller();
}

I hope this helps you to understand the reasoning of specializations and or partial specializations with class templates. With default constructible complete types you don't need specializations but with non default types you do other wise they are considered incomplete types.

Depending on your code base you may not have to specialize every sub class. It all depends on how they are constructed and if they are complete types.

Answer 3

template <typename T>
class Learner 
{
    static_assert(std::is_base_v<Base, T>); 

    T* _someRef;
    // ...
};