Re: Dynamic polymorphism and subclass template parameters?

And thus spake none <""mort\"@(none)">
Sat, 06 Mar 2010 18:32:56 +0100:


Since you do not show the template definitions, I am wildly
guessing here. Thus I can give only a very general answer.

A class template is just that: a template. There is no
polymorphic relation between template instantiations with
different parameters, thus they are distinct types. I.e.,
std::vector<int> is something quite different to
std::vector<double>. Thus, if you are trying to do something
like this:

template <typename T>
class base
{
  virtual void foo() = 0;
};

template <typename T>
class deriv : public base<T>
{
  virtual void foo() {}
}

then you will not be able to convert a deriv<Type1_t> to a
deriv<Type2_t>, since each of them creates 'its own' special
base-class from the base template. In other words, there cannot
be any dynamic polymorphism between the two. Inheritance in this
fashion still can have its uses. E.g. in combination with
partical specialisation techniques it can help avoid code
duplication, or the base can be instantiated directly with the
derived type ('curiously recurring template pattern'). But it
just will not work the way you probably intend it to.

What you have to do is base all your derived class templates
upon a non-templated class. I.e., this should work:

class base2
{
  virtual void foo() = 0;
};

template <typename T>
class deriv2 : public base2
{
  virtual void foo() {}
};

You can also use a templated base, but you will have to base all
derived templates on the same instantiation (i.e., one not
depending on the current template parameters). In other words,
this should be fine too:

template <typename T>
class deriv3 : public base<int>
{
  virtual void foo() {}
};

Regards,
Robert