设计模式-访问者模式-笔记

本文介绍: VIsitor模式通过所谓双重分发（double dis path）来实现在不更改（不添加新的操作—编译时）Element类层次结构的前提下，在运行时透明地为类层次结构上的各个类动态添加新的操作（支持变化）。在软件构建过程中，由于需求的变化，某些类层次结构中常常需要增加新的行为（方法），如果直接在基类中做这样的更改，将会给子类带来很繁重的变更负担，甚至破坏原有的设计。表示一个作用于某个对象结构中的各元素的操作。使得可以在不改变（稳定）各元素的类的前提下定义（扩展）作用于这些元素的新操作（变化）。

Visitor模式

动机（Moriv ation）

在软件构建过程中，由于需求的变化，某些类层次结构中常常需要增加新的行为（方法），如果直接在基类中做这样的更改，将会给子类带来很繁重的变更负担，甚至破坏原有的设计。

如果在不更改类层次结构的前提下，在运行是根据需要透明地为类层次结构上的各个类动态添加新的操作，从而避免上述问题？

模式定义：

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

示例1：

class Visitor;

class Element {
public:
    virtual void Func1() = 0;
    virtual void Func2(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：

#include <iostream&gt;
using namespace std;

class ElementA;
class ElementB;

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

class Element {
public:
    virtual void accept(Visitor* visitor) = 0;  //第一次动态辨析
    virtual ~Element() {}
};

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

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

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

class Visitor1 : public Visitor {
public:
    virtual void visitElementA(ElementA&amp; element) override {
        cout << "Visitor1 is processing ElementA" << endl;
    }

    virtual void visitElementB(ElementB&amp; element) override {
        cout << "Visitor1 is processing ElementB" << endl;
    }
};

class Visitor2 : public Visitor {
public:
    virtual void visitElementA(ElementA&amp; element) override {
        cout << "Visitor2 is processing ElementA" << endl;
    }

    virtual void visitElementB(ElementB&amp; element) override {
        cout << "Visitor2 is processing ElementB" << endl;
    }
};

int main() {

    Visitor2 visitor;
    ElementB element;
    element.accept(&amp;visitor);

    ElementA elementA;
    elementA.accept(&amp;visitor);

    return 0;
}