设计模式：访问者模式（C++实现）

访问者模式通过将对元素的操作与元素本身分离，使得可以在不修改元素类的情况下定义新的操作。

#include 
#include 
#include 

// 前向声明
class ConcreteElementA;
class ConcreteElementB;

// 访问者接口
class Visitor
{
public:
    virtual void visit(ConcreteElementA *element) = 0;
    virtual void visit(ConcreteElementB *element) = 0;
};

// 元素接口
class Element
{
public:
    virtual void accept(Visitor *visitor) = 0;
};

// 具体元素A
class ConcreteElementA : public Element
{
public:
    void accept(Visitor *visitor) override
    {
        visitor->visit(this);
    }

    void operationA()
    {
        std::cout << "ConcreteElementA operationA()" << std::endl;
    }
};

// 具体元素B
class ConcreteElementB : public Element
{
public:
    void accept(Visitor *visitor) override
    {
        visitor->visit(this);
    }

    void operationB()
    {
        std::cout << "ConcreteElementB operationB()" << std::endl;
    }
};

// 具体访问者
class ConcreteVisitor : public Visitor
{
public:
    void visit(ConcreteElementA *element) override
    {
        std::cout << "ConcreteVisitor visit ConcreteElementA" << std::endl;
        element->operationA();
    }

    void visit(ConcreteElementB *element) override
    {
        std::cout << "ConcreteVisitor visit ConcreteElementB" << std::endl;
        element->operationB();
    }
};

// 对象结构类
class ObjectStructure
{
private:
    std::vector<Element *> elements;

public:
    void addElement(Element *element)
    {
        elements.push_back(element);
    }

    void removeElement(Element *element)
    {
        auto it = std::find(elements.begin(), elements.end(), element);
        if (it != elements.end())
        {
            elements.erase(it);
        }
    }

    void accept(Visitor *visitor)
    {
        for (Element *element : elements)
        {
            element->accept(visitor);
        }
    }
};

int main()
{
    ObjectStructure objectStructure;

    ConcreteElementA elementA;
    ConcreteElementB elementB;

    objectStructure.addElement(&elementA);
    objectStructure.addElement(&elementB);

    ConcreteVisitor visitor;
    objectStructure.accept(&visitor);

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

运行结果：

ConcreteVisitor visit ConcreteElementA
ConcreteElementA operationA()
ConcreteVisitor visit ConcreteElementB
ConcreteElementB operationB()
1
2
3
4

在上述代码中，Visitor是访问者接口，定义了访问具体元素的方法。Element是元素接口，定义了接受访问者访问的方法。ConcreteElementA和ConcreteElementB是具体元素类，实现了元素接口。ConcreteVisitor是具体访问者类，实现了访问者接口。ObjectStructure是对象结构类，用于管理元素的集合，并提供接受访问者访问的方法。在main函数中，我们创建了具体元素A和B的实例，并将它们添加到对象结构中。然后创建了具体访问者的实例，并调用对象结构的accept方法，将访问者应用于所有元素。输出结果会显示访问者对不同元素的访问和操作。