Re: Alternative pattern for virtual template
GeeRay wrote:
Hi all,
I have this problem: I need to implement a class hierarchy where the
main class has a template method that will be inherited by the subclass.
Something like:
class SuperClass
{
public:
template<typename T>
virtual void foo(const T& t) const = 0;
}
class SubClass: public SuperClass
{
public:
template<typename T>
virtual void foo(const T& t) const { cout << t << endl;}
}
Considering I know why it is not possible to make a template virtual, is
there an alternative pattern to solve this kind of problems.
No. There are some things you can do but none of them generate the
equivalent of virtual template functions. Simple fact is that the
language doesn't support such a construct. How could it?
I find that any time I'm tempted to do this, my design is not exactly
correct.
The closest you might come is to use NVPI and account for every possible
argument to your template by hand:
struct Base
{
// Document the concept:
// T must be int or double.
template < typename T >
void f(T const& x);
protected:
virtual void do_f(double const& x) { ... }
virtual void do_f(int const& x) { ... }
};
template < >
void Base::f<double>(double const& x) { do_f(x); }
template < >
void Base::f<int>(int const& x) { do_f(x); }
Basically you're doing what the compiler would have to magically do if
it were to attempt supporting virtual template functions. As you can
see, pretty much impossible without full and future knowledge of all
calls to f<>(), which is why it isn't done.
I'm sure you could make some preprocessor stuff to construct much of the
above code, but you're still going to have to account for all possible
types passed to your function.
I'd suggest looking at alternative approaches.