Loki库里的Acyclic Visitor

已经知道，使用 Visitor有这样那样的不便。Loki为了避免这些提供了两个方案，之一就是Acyclic的类库化。

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

template    <class T,typename R = void>
class Visitor
...{
public:
    typedef    R    ReturnType;
    virtual    ReturnType    Visit(T&)    = 0;
};

你的访问者必须继承这两个类，具体的情况可能是：

class MyVisitor
    :public    BaseVisitor
    ,public    Visitor<A>
    ,public    Visitor<B>
...{
public:
    void    Visit(A&);    //visit A
    void    Visit(B&);    //visit B
}

使用起来很简单，记得继承和根据自己的特定类编写特定Visit方法就可以了。对于Visitable：

template    <typename    R = void>
class    BaseVisitable
...{
public:
    typedef    R    ReturnType;
    virtual    ~BaseVisitable()...{};
    virtual    ReturnType    Accept(BaseVisitor&)    = 0;
protected:
    template    <class T>
    static    ReturnType    AcceptImpl(T& visited,BaseVisitor& guest)
    ...{
        if (Visitor<T>* p = dynamic_cast<Visitor<T>*>(&guest))
        ...{
            return    p->Visit(visited);
        }
        return    ReturnType();
    }
};

#define    DEFINE_VISITABLE()    
    virtual    ReturnType    Accept(BaseVisitor& guest)    
    ...{return    AcceptImpl(*this,guest);}

你已经猜到，你的Visitable必须继承BaseVisitable，但是，Visit是要动态转换的，这个调用地方必须在子类中，放在基类中动态转换没有任何意义。为了提供侵入用户类的方便手段，loki定义了DEFINE_VISITABLE()宏，如果你对MFC有一定了解的话，你一定会觉得这种手法很熟悉。

当然，侵入宏只是为了只是动态转换，如果你需要，自己写也没什么，你还可以获得应有的自由度。

这样，一般的使用BaseVisitable的方法是：

class A    :public    BaseVisitable<>
...{
public:
    DEFINE_VISITABLE()
};

把宏替换为它的定义代码，修改Accept的实现就可以自定义AcceptImpl的行为。