C++怎么实现一个访问者设计模式_C++行为型模式与Visitor Pattern应用_技术教程

访问者模式将数据结构与操作分离，通过定义访问者接口实现对不同元素的扩展操作，新增行为无需修改元素类，符合开闭原则，适用于结构稳定、操作多变的场景。

访问者模式（Visitor Pattern）是C++中常用的行为型设计模式之一，适用于数据结构稳定但操作多变的场景。它将数据结构与作用于其上的操作分离，使得可以在不修改类的前提下定义新的操作。

访问者模式的核心思想

在访问者模式中，主要涉及两个部分：被访问的对象（元素）和访问者。元素负责接受访问者调用，而访问者实现对不同元素的具体操作。

这样做的好处是，当需要新增操作时，只需添加新的访问者类，而无需改动已有的元素类结构，符合开闭原则。

元素接口定义accept(Visitor&)方法
每个具体元素实现该方法，传入自身给访问者
访问者接口声明多个visit()重载函数，对应不同元素类型
具体访问者实现这些函数，完成特定逻辑

基本实现步骤

以下是一个简化示例，展示如何在C++中实现访问者模式：

#include 
#include 
using namespace std;

// 前向声明
class Visitor;

// 元素基类
class Element {
public:
    virtual ~Element() = default;
    virtual void accept(Visitor& visitor) = 0;
};

// 具体元素A
class ConcreteElementA : public Element {
public:
    void accept(Visitor& visitor) override;
    void operationA() const { cout << "执行元素A的操作\n"; }
};

// 具体元素B
class ConcreteElementB : public Element {
public:
    void accept(Visitor& visitor) override;
    void operationB() const { cout << "执行元素B的操作\n"; }
};

// 访问者基类
class Visitor {
public:
    virtual ~Visitor() = default;
    virtual void visit(const ConcreteElementA& element) = 0;
    virtual void visit(const ConcreteElementB& element) = 0;
};

// 实现accept方法
void ConcreteElementA::accept(Visitor& visitor) {
    visitor.visit(*this);
}

void ConcreteElementB::accept(Visitor& visitor) {
    visitor.visit(*this);
}

// 具体访问者：打印操作
class PrintVisitor : public Visitor {
public:
    void visit(const ConcreteElementA& element) override {
        cout << "PrintVisitor：";
        element.operationA();
    }

    void visit(const ConcreteElementB& element) override {
        cout << "PrintVisitor：";
        element.operationB();
    }
};

// 具体访问者：统计操作
class CountVisitor : public Visitor {
private:
    int count = 0;

public:
    void visit(const ConcreteElementA& element) override {
        cout << "CountVisitor：处理元素A，计数+1\n";
        ++count;
    }

    void visit(const ConcreteElementB& element) override {
        cout << "CountVisitor：处理元素B，计数+1\n";
        ++count;
    }

    int getCount() const { return count; }
};

使用方式与应用场景

构建对象结构后，通过统一接口调用不同访问者，实现解耦。

```cpp int main() { vector elements = { new ConcreteElementA(), new C

oncreteElementB(), new ConcreteElementA() };

PrintVisitor printVisitor;
CountVisitor countVisitor;

cout << "=== 执行打印访问 ===\n";
for (auto elem : elements) {
    elem->accept(printVisitor);
}

cout << "\n=== 执行统计访问 ===\n";
for (auto elem : elements) {
    elem->accept(countVisitor);
}

cout << "总共访问了 " << countVisitor.getCount() << " 个元素\n";

// 清理资源
for (auto elem : elements) {
    delete elem;
}

return 0;

}

输出结果：
PrintVisitor：执行元素A的操作
PrintVisitor：执行元素B的操作
PrintVisitor：执行元素A的操作

CountVisitor：处理元素A，计数+1
CountVisitor：处理元素B，计数+1
CountVisitor：处理元素A，计数+1
总共访问了 3 个元素