Question

I have the following problem with inheritance and templates:

class Base {};
class Deriv : public Base {};

template <class T> class X{};

void f(X<Base>& inst) {}

int main()
{
  X<Base> xb;
  f(xb);
  X<Deriv> xd;
  f(xd);
  return 0;
}

The program doesn’t compile because there is not relation between X<Base> and X<Deriv>. Nevertheless I think it should be possible to do everything that can be done with X<Base> also with X<Deriv>. Is there anything that I could do other than copying the function body of f to a new function void g(X<Deriv>& inst)?

Answer 1

Why do you think they should be related? Consider the following:

template<typename T>
class X;

template<>
class X<Base> {
    int x;
};

template<>
class X<Deriv> {
    double d;
};

They’re definitely not interchangeable. So no, there is no relation between those classes and you can’t pass one to a function expecting the other. You’ll have to do something like make both types inherit from another common type that exposes the interface you need.

---

Regarding your comment, you can use type traits and static_assert to do what you would do in Java:

template<typename T>
void f(X<T>& inst) {
    static_assert(std::is_base_of(Base, T)::value, "Template type must subclass Base");

    // body of function...
}