Inteface classes for generic application of visitor pattern - c++

Question

I faced a problem that could be solved with the visitor pattern, and because I love reusable code I thought it might be a good idea to have some classes that already do most of the magic for me and which I could reuse later. So what I wanted was something like a Visitor class and a Visitable class, from which I can derive to prepare my deriving class for the use of the visitor pattern. I came up with this code:
template <typename ret = void>
class Visitor
{
public:
typedef ret ReturnType;
protected:
Visitor() {}
~Visitor() {}
};
template <typename BaseType>
class Visitable
{
public:
template <typename Visitor>
typename Visitor::ReturnType applyVisitor(Visitor& visitor)
{
return visitor(static_cast<BaseType*>(this));
}
template <typename Visitor>
typename Visitor::ReturnType applyVisitor(Visitor& visitor) const
{
return visitor(static_cast<BaseType*>(this));
}
protected:
Visitable() {}
~Visitable() {}
};
template <typename VisitorType, typename VisitableType>
inline typename VisitorType::ReturnType applyVisitor(VisitorType visitor, VisitableType visitable)
{
return visitable->applyVisitor(visitor);
}
class Base : public Visitable <Base>
{
public:
virtual void foo() const
{
std::cout << "BASE" << std::endl;
};
std::string foobar() const
{
return "BASE";
};
};
class Derived : public Base, public Visitable<Derived>
{
public:
using Visitable<Derived>::applyVisitor;
void foo() const
{
std::cout << "DERIVED" << std::endl;
};
std::string bar() const
{
return "DERIVED";
};
};
struct MyVisitor : public Visitor < >
{
template <class T>
void operator()(T const var) const
{
var->foo();
}
};
struct MyOtherVisitor : public Visitor <std::string>
{
std::string operator()(Base * const var) const
{
return var->foobar();
}
std::string operator()(Derived * const var) const
{
return var->bar();
}
};
int main(int _Argc, char* _Argv)
{
Base *pVirtualDerived = new Derived();
Base *pBase = new Base();
Derived *pDerived = new Derived();
std::cout << "Member method:" << std::endl;
applyVisitor(MyVisitor(), pVirtualDerived);
applyVisitor(MyVisitor(), pBase);
applyVisitor(MyVisitor(), pDerived);
std::cout << std::endl << "External method:" << std::endl;
std::cout << applyVisitor(MyOtherVisitor(), pVirtualDerived) << std::endl;
std::cout << applyVisitor(MyOtherVisitor(), pBase) << std::endl;
std::cout << applyVisitor(MyOtherVisitor(), pDerived) << std::endl;
}
As one might already guess from the names I was inspired by boost::static_visitor and boost::variant. However, one can also notice that my implementation is flawed in two aspects:
It does not suffice to just inherit from Visitable, I also need to put a using declaration into my class to resolve ambiguity for the applyVisitor method.
It is not really the visitor pattern. Calling applyVisitor with a Base* that actually points to a Derived object does not call Derived::foo but Base::foo. I cannot declare applyVisitor in Visitable<T> virtual because it is a templated method. But I need the template because Visitor<T> is a template class it self and I would like to keep the generic return type for my visitors.
Long story short, can I somehow solve both problems and end up with two classes from which I simply need to derive to prepare my code for the visitor pattern?

Answer 1

There are lots of things to talk about Visitor Design Patterns and C++ inheritance. In the specific case that you described, I think the solutions are:
About the first problem, since the Base class is already inheriting from Visitable, you don't need to inherit from it again in the derived class:
class Derived : public Base
{
public:
void foo() const
{
std::cout << "DERIVED" << std::endl;
};
};
About the second problem, I think you just forgot the virtual keyword in the Base class:
class Base : public Visitable<Base>
{
public:
virtual void foo() const
{
std::cout << "BASE" << std::endl;
};
};