Virtual template function visitor workaround with template derived classes - c++

Question

The problem is that template <typename T> virtual void foo() is illegal, and I'm trying to use the visitor pattern to workaround that (which is known to work in general). However the derived classes of Base are template classes, and now I'm running into the virtual template problem within the visitor classes. How to work around this?
struct Base {
// template <typename T> virtual void foo() = 0; // illegal
virtual void foo (class Visitor& visitor) = 0; // The attempted solution
};
template <typename D>
struct Derived : Base {
virtual void foo (Visitor&) override;
};
struct Visitor {
//template <typename D> // same problem again!
virtual void visit (Derived<D>*) const = 0;
};
template <typename T, typename D>
struct FooVisitor : Visitor {
virtual void visit (Derived<D>*) const override {/*Do whatever with T*/}
};
template <typename D>
void Derived<D>::foo (Visitor& visitor) {visitor.visit(this);}
With all solutions, let's assume there shall be about one hundred values for D, with new D classes being introduced constantly. And each will use D in the same way. For simplicity, let's assume each visit function will use D with
func<D>();
where
template <typename D> void Base::func();
is some helper function in Base.

Answer 1

Here is a solution that might work. Note that the assumption here is that you only make invocations with the right type:
struct Base {
virtual void foo(struct Visitor& visitor) = 0;
};
template <typename D>
struct Derived : Base {
virtual void foo (Visitor&v) override;
};
struct Visitor {
virtual ~Visitor() {} // Make this class polymorphic.
};
template <typename D>
struct Visitor_tmpl : public Visitor {
virtual void visit (Derived<D>*) const {/*Do whatever with T*/}
};
template <typename T, typename D>
struct FooVisitor : Visitor_tmpl<D> {
virtual void visit (Derived<D>*) const override {/*Do whatever with T*/}
};
template <typename D>
void Derived<D>::foo(Visitor&v) {
// In this function, D has been bound now to a specific type, so we downcast.
// It will throw an exception if not the right type.
dynamic_cast<Visitor_tmpl<D> &>(v).visit(this);
}
int main() {
Derived<int> d;
FooVisitor<double, int> v;
d.foo(v);
}

Answer 2

One possible solution was mentioned by Jarod42, namely to specify all possibly occuring types. Usually, however, you want to give a standard implementation taking a Base* as well, and overload this only when required.
struct Type1 {};
//...
struct TypeN {};
struct Visitor
{
virtual ~Visitor() {}
virtual void visit (Base*) const = 0;
virtual void visit (Derived<Type1>* d) const { visit(static_cast<Base*>(d)); };
//...
virtual void visit (Derived<TypeN>* d) const { visit(static_cast<Base*>(d)); };
};
struct FooVisitor : public Visitor
{
virtual void visit (Base* base) const override
{
std::cout<<"visiting base class."<<std::endl;
}
//further definitions for those types that require a special implementation
virtual void visit (Derived<TypeN>* d) const override
{
std::cout<<"visiting class of type Derived<TypeN>."<<std::endl;
}
};
DEMO
EDIT: Here is another possibility using basic double dispatch:
struct Visitor
{
virtual ~Visitor() {}
virtual void visit (Base*) const = 0;
};
struct FooVisitor : public Visitor
{
virtual void visit (Base* base) const override
{
if(Derived<TypeN>* d = dynamic_cast<Derived<TypeN>*>(base))
{
std::cout<<"visiting class of type Derived<TypeN>."<<std::endl;
}
else
{
std::cout<<"visiting base class."<<std::endl;
}
}
};
It releases you from declaring each possible variable type in the base class, but is probably less efficient than the previous solution.
This brute-force approach has some other disadvantages, which are collected in chapter 11 of Alexandrescu's book. You can also read there how to overcome these disadvantages by using a static dispatcher. Basically there you just enter once the types you want to consider for dispatching, and let the code create the above logic.
DEMO