访问者模式

前言

访问者模式：表示一个作用于某对象结构中的各元素的操作，它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。

访问者模式的目的是要把处理从数据结构分离出来。很多系统可以按照算法和数据结构分开，如果这样的系统有比较稳定的数据结构，又有易于变化的算法的话，使用访问者模式就是比较合适的 ，因为访问者模式使得算法操作的增加变得容易。

注意：访问者模式的能力和复杂性是把双刃剑，只有当你真正需要它的时候，才考虑使用它。

Visitor 模式在不破坏类的前提下， 为类提供增加新的新操作。 Visitor 模式的关键是双分派（ Double-Dispatch） 的技术。 C++语言支持的是单分派。

在 Visitor 模式中 Accept()操作是一个双分派的操作。具体调用哪一个具体的 Accept()操作，有两个决定因素：
1） Element 的类型。因为 Accept()是多态的操作，需要具体的 Element 类型的子类才可以决定到底调用哪一个 Accept()实现；
2） Visitor 的类型。Accept()操作有一个参数(Visitor* vis)，要决定了实际传进来的 Visitor 的实际类别才可以决定具体是调用哪个 VisitConcrete()实现。

代码

Element.h

#ifndef ELEMENT_H
#define ELEMENT_H
class Visitor;

class Element {
public:
    virtual ~Element() = default;
    virtual void Accept(Visitor* vis) = 0;
protected:
    Element() = default;
};

class ConcreteElementA:public Element
{
public:
    ConcreteElementA() = default;
    ~ConcreteElementA() = default;
    void Accept(Visitor* vis);
};

class ConcreteElementB:public Element
{
public:
    ConcreteElementB() = default;
    ~ConcreteElementB() = default;
    void Accept(Visitor* vis);
};
#endif //ELEMENT_H

Element.cpp

#include "Element.h"
#include "Visitor.h"
#include <iostream>

using namespace std;

void ConcreteElementA::Accept(Visitor *vis) {
    vis->visitConcreteElementA(this);
    cout << "visiting ConcreteElementA..."<<endl;
}

void ConcreteElementB::Accept(Visitor *vis) {
    cout << "visiting ConcreteElementB..."<<endl;
    vis->visitConcreteElementA(this);
}

Visitor.h

#ifndef VISITOR_H
#define VISITOR_H

class ConcreteElementA;
class ConcreteElementB;
class Element;

class Visitor {
public:
    virtual ~Visitor() = default;
    virtual void visitConcreteElementA(Element* element) = 0;
    virtual void visitConcreteElementB(Element* element) = 0;
protected:
    Visitor() = default;
};

class ConcreteElementA:public Visitor
{
public:
    ConcreteElementA() = default;
    virtual ~ConcreteElementA() = default;
    virtual void visitConcreteElementA(Element* element);
    virtual void visitConcreteElementB(Element* element);
};

class ConcreteElementB:public Visitor
{
public:
    ConcreteElementB() = default;
    virtual ~ConcreteElementB() = default;
    virtual void visitConcreteElementA(Element* element);
    virtual void visitConcreteElementB(Element* element);
};
#endif //VISITOR_H

Visitor.cpp

#include "Visitor.h"
#include "Element.h"
#include <iostream>
using namespace std;

void ConcreteElementA::visitConcreteElementA(Element *element) {
    cout<<"i will visit ConcreteElementA..."<<endl;
}

void ConcreteElementA::visitConcreteElementB(Element *element) {
    cout<<"i will visit ConcreteElementB..."<<endl;
}

void ConcreteElementB::visitConcreteElementA(Element *element) {
    cout<<"i will visit ConcreteElementA..."<<endl;
}

void ConcreteElementB::visitConcreteElementB(Element *element) {
    cout<<"i will visit ConcreteElementB..."<<endl;
}

main.cpp

#include "Visitor.h"
#include "Element.h"
#include <iostream>

using namespace std;

int main() {
    Visitor* vis = new ConcreteElementA();
    Element* elem = new ConcreteElementA();
    elem->Accept(vis);
    return 0;
}

注意：按照单分派和双分派之分，代码运行目前存在问题。