【GeekBand】C++设计模式笔记24_Visitor_访问器

1. “行为变化” 模式

• 在组件的构建过程中，组件行为的变化经常导致组件本身剧烈的变化。“行为变化” 模式将组件的行为和组件本身进行解耦，从而支持组件行为的变化，实现两者之间的松耦合。
• 典型模式
  • Command
  • Visitor

2. Visitor 访问器

2.1 动机（Motivation）

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

2.2 模式定义

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

2.3 实例代码

2.3.1 非访问器模式

#include <iostream>
using namespace std;

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 {
        //***
    } 
};

2.3.2 访问器模式

#include <iostream>
using namespace std;

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);	// 第二次多态辨析
    }
};

// Visitor 基类
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;
}

2.4 结构（Structure）

2.5 要点总结

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