24-访问器（Visitor）

1. 定义

表示一个作用于某对象结构中的各元素的操作。使得可以在不改变（稳定）各元素的类的前提下定义（扩展）作用于这些元素的新操作（变化）。

2. 适用场景

• 在软件构建过程中，由于需求的改变，某些类层次结构中常常需要增加新的行为（方法），如果直接在基类中做这样的更改，将会给子类带来很繁重的变更负担，甚至破坏原有设计。
• 如何在不更改类层次结构的前提下，在运行时根据需要透明地为类层次结构上的各个类动态添加新的操作，从而避免上述问题？

3. 要点总结

• Visitor模式通过所谓的双重分发（double dispatch）来实现在不更改（不添加新的操作-编译时）Element类层次结构的前提下，在运行时透明地为类层次结构上的各个类动态添加新的操作（支持变化）。
• 所谓双重分发即Visitor模式中间包括了两个多态分发（注意其中的多态机制）；第一个为accept方法的多态辨析；第二个为visitElementX方法的多态辨析。
• Visitor模式的最大缺点在于扩展类层次结构（增添新的Element子类），会导致Visitor类的改变。因此Visitor模式适用于“Element类层次结构稳定，而其中的操作经常面临频繁改动”。

4. Demo

4.1 常规场景

class Visitor;


class Element
{
public:
    virtual void Func1() = 0;
    
    virtual void Func2(int data)=0;
    virtual void Func3(int data)=0;
    //...
    
    virtual ~Element(){}
};

class ElementA : public Element
{
public:
    void Func1() override{
        //...
    }
    
    void Func2(int data) override{
        //...
    }
    
};

class ElementB : public Element
{
public:
    void Func1() override{
        //***
    }
    
    void Func2(int data) override {
        //***
    }
    
};

4.2 使用Visitor

class Visitor;


class Element
{
public:
    virtual void accept(Visitor& visitor) = 0; //第一次多态辨析

    virtual ~Element(){}
};

class ElementA : public Element
{
public:
    void accept(Visitor &visitor) override {
        visitor.visitElementA(*this);
    }
    

};

class ElementB : public Element
{
public:
    void accept(Visitor &visitor) override {
        visitor.visitElementB(*this); //第二次多态辨析
    }

};

class Visitor{
public:
    virtual void visitElementA(ElementA& element) = 0;
    virtual void visitElementB(ElementB& element) = 0;
    
    virtual ~Visitor(){}
};

//==================================

//扩展1
class Visitor1 : public Visitor{
public:
    void visitElementA(ElementA& element) override{
        cout << "Visitor1 is processing ElementA" << endl;
    }
        
    void visitElementB(ElementB& element) override{
        cout << "Visitor1 is processing ElementB" << endl;
    }
};
     
//扩展2
class Visitor2 : public Visitor{
public:
    void visitElementA(ElementA& element) override{
        cout << "Visitor2 is processing ElementA" << endl;
    }
    
    void visitElementB(ElementB& element) override{
        cout << "Visitor2 is processing ElementB" << endl;
    }
};
                  
int main()
{
    Visitor2 visitor;
    ElementB elementB;
    elementB.accept(visitor);// double dispatch
    
    ElementA elementA;
    elementA.accept(visitor);

    return 0;
}

---

本专栏文章：

• 01-C++面向对象设计原则
• 02-C++模式概述
• 03-模板方法（Template Method）
• 04-策略模式（Strategy）
• 05-观察者模式（Observer）
• 06-装饰模式（Decorator）
• 07-桥模式（Bridge）
• 08-工厂方法（Factory Method）
• 09-抽象工厂（Abstract Factory）
• 10-原型模式（Prototype）
• 11-构建器（Builder）
• 12-单件模式（Singleton）
• 13-享元模式（Flyweight）
• 14-门面模式（Façade）
• 15-代理模式（Proxy）
• 16-适配器（Adapter）
• 17-中介者（Mediator）
• 18-状态模式（State）
• 19-备忘录（Memento）
• 20-组合模式（Composite）
• 21-迭代器（Iterator）
• 22-职责链（Chain of Resposibility）
• 23-命令模式（Command）
• 24-访问器（Visitor）
• 25-解析器（Interpreter）
• 26-C++设计模式总结