c++ - Using the Visitor Pattern with template derived classes

Question

I try to implement the Visitor pattern with templated derived classes

I work with gcc 4.5

here is the VisitorTemplate.hpp, I specialized Derived in the class Visitor, but I'd like to be able to handle any type:

edit : thanks to the suggestions of interjay, the code compiles and runs without errors now

#ifndef VISITORTEMPLATE_HPP_
#define VISITORTEMPLATE_HPP_

#include <iostream>
#include <string>
using namespace std;

template<class T> Derived;

class Visitor
{
  public:
    virtual void visit(Derived<string> *e) = 0;
};

class Base
{
  public:
    virtual void accept(class Visitor *v) = 0;
};

template<class T>
Derived: public Base
{
  public:
    virtual void accept(Visitor *v)
    {
       v->visit(this);
    }
    string display(T arg)
    {
       string s = "This is : " + to_string(arg);
       return s;
    }
};

class UpVisitor: public Visitor
{
   virtual void visit(Derived<string> *e)
   {
     cout << "do Up on " + e->display("test") << '
';
   }
};

class DownVisitor: public Visitor
{
   virtual void visit(Derived<string> *e)
   {
     cout << "do Down on " + e->display("test") << '
';
   }
};

#endif /* VISITORTEMPLATE_HPP_ */

main.cpp

Base* base = new Derived<string>();
Visitor* up = new UpVisitor();
Visitor* down = new DownVisitor();
base->accept(up);
base->accept(down);

Now my goal is to use Derived in visit without specializing; unfortunately, visit is a virtual method so I can't template it

Answer 1

From Modern C++ - Design Generic Programming and Design Patterns Applied - Andrei Alexandrescu

#include <iostream>

class BaseVisitor
{
    public:
        virtual ~BaseVisitor() {};
};

template <class T, typename R = int>
class Visitor
{
    public:
        virtual R visit(T &) = 0;
};

template <typename R = int>
class BaseVisitable
{
    public:
        typedef R ReturnType;
        virtual ~BaseVisitable() {};
        virtual ReturnType accept(BaseVisitor & )
        {
            return ReturnType(0);
        }
    protected:
        template <class T>
        static ReturnType acceptVisitor(T &visited, BaseVisitor &visitor)
        {
            if (Visitor<T> *p = dynamic_cast< Visitor<T> *> (&visitor))
            {
                return p->visit(visited);
            }
            return ReturnType(-1);
        }

        #define VISITABLE() 
            virtual ReturnType accept(BaseVisitor &v) 
                { return acceptVisitor(*this, v); }
};


/** example of use */
class Visitable1 : public BaseVisitable<int>
{
    /* Visitable accept one BaseVisitor */
    public:
        VISITABLE();
};

class Visitable2 : public BaseVisitable<int>
{
    /* Visitable accept one BaseVisitor */
    public:
        VISITABLE();
};

class VisitorDerived : public BaseVisitor,
        public Visitor<Visitable1, int>,
        public Visitor<Visitable2, int>
{
    public:
        int visit(Visitable1 & c)
        {
            std::cout << __PRETTY_FUNCTION__ << std::endl;
        }
        int visit(Visitable2 & c)
        {
            std::cout << __PRETTY_FUNCTION__ << std::endl;
        }
};

int main(int argc, char **argv)
{
    VisitorDerived visitor;
    Visitable1 visitable1;
    Visitable2 visitable2;

    visitable1.accept(visitor);
    visitable2.accept(visitor);
}

Is possible to avoid dynamic_cast with CRTP pattern like:

#include <iostream>

class BaseVisitor
{
    public:
        virtual ~BaseVisitor() {};
};

template <class T>
class Visitor
{
    public:
        virtual void visit(T &) = 0;
};

template <class Visitable>
class BaseVisitable
{ 
    public:
        template <typename T>
        void accept(T & visitor)
        {
            visitor.visit(static_cast<Visitable &>(*this));
        }
};

/** example of use */
class Visitable1 : public BaseVisitable<Visitable1>
{
};

class Visitable2 : public BaseVisitable<Visitable2>
{
};

class VisitorDerived : public BaseVisitor, 
                       public Visitor<Visitable1>,
                       public Visitor<Visitable2>
{
    public:
        void visit(Visitable1 & c)
        {
            std::cout << __PRETTY_FUNCTION__ << std::endl;
        }
        void visit(Visitable2 & c)
        {
            std::cout << __PRETTY_FUNCTION__ << std::endl;
        }
};

int main(int argc, char **argv)
{
    VisitorDerived visitor;
    Visitable1 visitable1;
    Visitable2 visitable2;

    visitable1.accept<VisitorDerived>(visitor);
    visitable2.accept<VisitorDerived>(visitor);
}