突破编程_C++_设计模式（访问者模式）

1 访问者模式的基本概念

C++中的访问者模式是一种行为设计模式，它允许你在不修改类层次结构的情况下增加新的操作。这种模式将数据结构与数据操作解耦，使得操作可以独立于对象的类来定义。

访问者模式的主要组成部分包括：

（1）访问者（Visitor）： 这是一个接口，它声明了一个访问操作，该操作可以被应用到所有的元素上。访问操作的具体实现在访问者的子类中完成。

（2）元素（Element）： 这是一个接口，它定义了一个接受操作，该操作可以被一个访问者访问。元素接口通常有一个接受访问者作为参数的接受方法。

（3）具体元素（Concrete Element）： 这是实现元素接口的具体类，它实现了接受方法，该方法将调用访问者的访问方法。

（4）对象结构（Object Structure）： 这是元素的集合，它以一种合适的方式包含元素。对象结构可以是一个简单的集合，也可以是一个复杂的树形结构。

2 访问者模式的实现步骤

访问者模式的实现步骤如下：

（1）定义访问者接口：

首先，需要定义一个访问者接口，这个接口声明了所有可能应用于元素对象的操作。这些操作通常作为纯虚函数存在，具体的操作实现将由具体的访问者类来完成。

（2）定义元素接口：

接下来，定义一个元素接口，这个接口声明了一个接受方法，该方法接受一个访问者对象作为参数。元素接口中的接受方法通常是虚函数，以便在元素的具体类中实现多态性。

（3）实现具体元素类：

然后，创建实现元素接口的具体元素类。这些类将包含数据，并实现接受方法，该方法将调用访问者的访问方法。

（4）实现具体的访问者类：

接着，创建实现访问者接口的具体访问者类。这些类将包含访问元素所需的具体逻辑。当访问者的访问方法被调用时，它将针对具体的元素对象执行相应的操作。

（5）创建对象结构：

创建一个对象结构，该结构负责管理元素对象的集合。这可以是一个简单的容器，如数组或向量，也可以是一个更复杂的结构，如树或图。

（6）使用访问者模式：

最后，在客户端代码中，创建具体的访问者对象，并通过对象结构访问元素对象。当需要执行某个操作时，通过对象结构的遍历方法，将具体的访问者对象传递给每个元素对象的接受方法。元素对象的接受方法将调用访问者的访问方法，从而执行相应的操作。

如下为样例代码：

#include <iostream>  
#include <vector>  
#include <memory>  class Element;// 步骤一：定义访问者接口  
class Visitor {
public:virtual ~Visitor() = default;virtual void visit(const std::shared_ptr<Element>& element) const = 0;
};// 步骤二：定义元素接口  
class Element : public std::enable_shared_from_this<Element> {
public:virtual ~Element() = default;virtual void accept(const std::shared_ptr<Visitor>& visitor) = 0;
};// 步骤三：实现具体元素类  
class ConcreteElement : public Element {
public:void accept(const std::shared_ptr<Visitor>& visitor) override {visitor->visit(shared_from_this());}void operation() const {std::cout << "ConcreteElement operation" << std::endl;}
};// 步骤四：实现具体的访问者类  
class ConcreteVisitor : public Visitor {
public:void visit(const std::shared_ptr<Element>& element) const override {auto concreteElement = std::dynamic_pointer_cast<ConcreteElement>(element);if (concreteElement) {concreteElement->operation();std::cout << "Visited by ConcreteVisitor" << std::endl;}else {std::cout << "Element is not of type ConcreteElement" << std::endl;}}
};// 步骤五：创建对象结构  
class ObjectStructure {
public:void attach(const std::shared_ptr<Element>& element) {m_elements.push_back(element);}void detach(const std::shared_ptr<Element>& element) {auto it = std::find(m_elements.begin(), m_elements.end(), element);if (it != m_elements.end()) {m_elements.erase(it);}}void accept(const std::shared_ptr<Visitor>& visitor) const {for (const auto& element : m_elements) {element->accept(visitor);}}private:std::vector<std::shared_ptr<Element>> m_elements;
};// 步骤六：使用访问者模式  
int main() 
{// 创建对象结构并添加元素  ObjectStructure objectStructure;objectStructure.attach(std::make_shared<ConcreteElement>());// 创建访问者  std::shared_ptr<Visitor> visitor = std::make_shared<ConcreteVisitor>();// 执行访问  objectStructure.accept(visitor);return 0;
}

上面代码的输出为：

ConcreteElement operation
Visited by ConcreteVisitor

上面的代码使用了 std::shared_ptr 智能指针来管理 Visitor 和 Element 对象的生命周期。std::dynamic_pointer_cast 用于安全地执行动态类型转换，以确认 Element 指针是否可以转换为 ConcreteElement 类型。如果转换成功，则执行相应的操作。

ObjectStructure 类负责管理 Element 对象的集合，并提供 attach 和 detach 方法来添加和删除元素。accept 方法则遍历所有元素，并将访问者传递给每个元素的 accept 方法，从而执行访问操作。

在 main 函数中，创建了一个 ObjectStructure 对象，并向其添加了一个 ConcreteElement 对象。然后，创建了一个 ConcreteVisitor 对象，并通过 ObjectStructure 的 accept 方法将访问者传递给所有元素。这样，就实现了访问者模式的使用。

3 访问者模式的应用场景

C++ 访问者模式的应用场景广泛，主要适用于以下情况：

（1）双层分派场景： 访问者模式实现了一种称为“双层分派”的机制。第一层分派发生在客户端代码中，当客户端将访问者对象传递给元素对象的 accept 方法时。第二层分派发生在元素对象的 accept 方法内部，它根据访问者的类型调用相应的访问方法。这种双层分派机制使得操作可以在元素对象的上下文中执行，并且可以根据元素的类型进行不同的处理。

（2）数据结构稳定但操作易变的场景： 如果数据结构相对稳定，但需要在其上执行的操作经常变化，访问者模式可以帮助将这些操作与数据结构解耦，使得操作的变化不会影响到数据结构的定义。

（3）操作需要扩展的场景： 当需要对一个对象结构中的元素执行多种不同的、不相关的操作时，且这些操作可能会在未来发生变化或增加时，使用访问者模式非常合适。通过将操作封装在访问者中，可以在不修改元素类的情况下添加新的操作。

（4）需要对对象结构中的对象进行不同操作的场景： 当需要在运行时决定对对象结构中的哪些元素执行哪些操作时，访问者模式可以很容易地实现这种动态行为。

（5）复杂的对象结构遍历： 当需要遍历一个复杂的对象结构（如树形结构、图结构等），并对结构中的每个元素执行特定的操作时，访问者模式可以简化代码结构，使得遍历和操作逻辑更加清晰和分离。

3.1 访问者模式应用于双层分派场景

双层分派允许根据对象类型和访问者类型动态地决定执行哪个操作。以下是一个简单的游戏场景，其中游戏角色可以被不同的访问者（例如渲染器或AI处理器）访问。

首先，定义访问者接口和元素接口：

#include <iostream>  
#include <memory>  
#include <vector>  
#include <string>  class Character;// 访问者接口  
class Visitor {
public:virtual ~Visitor() = default;virtual void visit(const std::shared_ptr<Character>& character) const = 0;
};// 元素接口  
class Character : public std::enable_shared_from_this<Character> {
public:virtual ~Character() = default;virtual void accept(const std::shared_ptr<Visitor>& visitor) = 0;virtual std::string getName() const = 0;
};

接着，定义具体的游戏角色类和访问者类：

// 具体游戏角色类A  
class Warrior : public Character {
public:std::string getName() const override { return "Warrior"; }void accept(const std::shared_ptr<Visitor>& visitor) override {visitor->visit(shared_from_this());}void fight() const {std::cout << getName() << " is fighting!" << std::endl;}
};// 具体游戏角色类B  
class Mage : public Character {
public:std::string getName() const override { return "Mage"; }void accept(const std::shared_ptr<Visitor>& visitor) override {visitor->visit(shared_from_this());}void castSpell() const {std::cout << getName() << " is casting a spell!" << std::endl;}
};// 具体访问者类：渲染器  
class Renderer : public Visitor {
public:void visit(const std::shared_ptr<Character>& character) const override {std::cout << "Rendering " << character->getName() << std::endl;}
};// 具体访问者类：AI处理器  
class AIProcessor : public Visitor {
public:void visit(const std::shared_ptr<Character>& character) const override {std::cout << "Processing AI for " << character->getName() << std::endl;// 这里可以根据角色类型执行不同的AI逻辑  }
};

最后，定义一个管理游戏角色的对象结构类，并使用访问者进行双层分派：

// 对象结构类：游戏世界  
class GameWorld {
public:void addCharacter(const std::shared_ptr<Character>& character) {m_characters.push_back(character);}void render(const std::shared_ptr<Visitor>& visitor) const {for (const auto& character : m_characters) {character->accept(visitor);}}private:std::vector<std::shared_ptr<Character>> m_characters;
};int main() 
{// 创建游戏角色  auto warrior = std::make_shared<Warrior>();auto mage = std::make_shared<Mage>();// 创建游戏世界并添加角色  GameWorld gameWorld;gameWorld.addCharacter(warrior);gameWorld.addCharacter(mage);// 创建渲染器访问者  auto renderer = std::make_shared<Renderer>();// 使用渲染器访问者渲染所有角色  gameWorld.render(renderer);// 创建AI处理器访问者  auto aiProcessor = std::make_shared<AIProcessor>();// 使用AI处理器访问者处理所有角色的AI  gameWorld.render(aiProcessor);// 不需要手动释放对象，智能指针会自动处理  return 0;
}

上面代码的输出为：

Rendering Warrior
Rendering Mage
Processing AI for Warrior
Processing AI for Mage

在这个示例中，Warrior 和 Mage 类继承了 Character 接口，并实现了各自的 accept 方法和特定行为（如 fight 和 castSpell）。Renderer 和 AIProcessor 类继承了 Visitor 接口，并实现了针对 Character 的 visit 方法。

GameWorld 类管理着游戏中的角色，并提供了 render 方法，该方法接受一个 Visitor 智能指针，并使用 accept 方法触发双层分派。当调用 gameWorld.render(renderer) 时，所有角色都会被渲染器访问，并调用它们各自的 accept 方法。由于 accept 方法内部调用了 visitor->visit(shared_from_this())，这就会触发对应的 visit 方法，在这里是 Renderer 类的 visit 方法，负责渲染角色。

3.2 访问者模式应用数据结构稳定但操作易变的场景

该场景是指：对于一组稳定的数据结构（元素），在这些数据结构上执行各种易变的操作（访问者）时，每个操作可能需要访问数据结构的不同部分，并且可能以不同的方式处理这些部分。

下面是一个使用访问者模式的示例，它模拟了一个简单的形状集合，其中形状是稳定的数据结构，而不同的操作（如计算面积、周长等）是易变的访问者。

首先，定义形状接口和访问者接口：

#include <iostream>  
#include <memory>  
#include <vector>  class Visitor;// 形状接口  
class Shape : public std::enable_shared_from_this<Shape> {
public:virtual ~Shape() = default;virtual void accept(const std::shared_ptr<Visitor>& visitor) = 0;
};class Circle;
class Rectangle;// 访问者接口  
class Visitor {
public:virtual ~Visitor() = default;virtual void visit(const std::shared_ptr<Circle>& circle) const = 0;virtual void visit(const std::shared_ptr<Rectangle>& rectangle) const = 0;
};

接着，定义具体的形状类和访问者类：

// 圆形类  
class Circle : public Shape {double radius;
public:Circle(double r) : radius(r) {}void accept(const std::shared_ptr<Visitor>& visitor) override {visitor->visit(std::dynamic_pointer_cast<Circle>(shared_from_this()));}double getRadius() const { return radius; }
};// 矩形类  
class Rectangle : public Shape {double width, height;
public:Rectangle(double w, double h) : width(w), height(h) {}void accept(const std::shared_ptr<Visitor>& visitor) override {visitor->visit(std::dynamic_pointer_cast<Rectangle>(shared_from_this()));}double getWidth() const { return width; }double getHeight() const { return height; }
};// 计算面积的访问者  
class AreaVisitor : public Visitor {
public:void visit(const std::shared_ptr<Circle>& circle) const override {std::cout << "Circle area: " << 3.14159 * circle->getRadius() * circle->getRadius() << std::endl;}void visit(const std::shared_ptr<Rectangle>& rectangle) const override {std::cout << "Rectangle area: " << rectangle->getWidth() * rectangle->getHeight() << std::endl;}
};// 计算周长的访问者  
class PerimeterVisitor : public Visitor {
public:void visit(const std::shared_ptr<Circle>& circle) const override {std::cout << "Circle perimeter: " << 2 * 3.14159 * circle->getRadius() << std::endl;}void visit(const std::shared_ptr<Rectangle>& rectangle) const override {std::cout << "Rectangle perimeter: " << 2 * (rectangle->getWidth() + rectangle->getHeight()) << std::endl;}
};

最后，创建一个管理形状的对象结构类，并使用访问者进行操作：

// 对象结构类：形状集合  
class ShapeCollection {
public:void addShape(const std::shared_ptr<Shape>& shape) {m_shapes.push_back(shape);}void process(const std::shared_ptr<Visitor>& visitor) const {for (const auto& shape : m_shapes) {shape->accept(visitor);}}private:std::vector<std::shared_ptr<Shape>> m_shapes;
};int main() 
{// 创建形状  auto circle = std::make_shared<Circle>(5.0);auto rectangle = std::make_shared<Rectangle>(4.0, 6.0);// 创建形状集合并添加形状  ShapeCollection collection;collection.addShape(circle);collection.addShape(rectangle);// 创建并使用面积访问者  auto areaVisitor = std::make_shared<AreaVisitor>();collection.process(areaVisitor);// 创建并使用周长访问者  auto perimeterVisitor = std::make_shared<PerimeterVisitor>();collection.process(perimeterVisitor);// 不需要手动释放对象，智能指针会自动处理  return 0;
}

上面代码的输出为：

Circle area: 78.5397
Rectangle area: 24
Circle perimeter: 31.4159
Rectangle perimeter: 20

在这个示例中，Circle 和 Rectangle 类继承了 Shape 接口，并实现了各自的 accept 方法和特定行为（半径以及长宽）。AreaVisitor 和 PerimeterVisitor 类继承了 Visitor 接口，并实现了计算圆形面积周长以及计算矩形面积周长的 visit 方法。随后在 ShapeCollection 的 process 进行访问调用。

4 访问者模式的优点与缺点

C++ 访问者模式的优点主要包括：

（1）扩展性好： 访问者模式使得在不修改已有类的情况下，可以添加新的操作。这意味着数据结构本身保持稳定，而新的操作可以很容易地添加到系统中。

（2）操作集中管理： 访问者模式将相关的操作集中到一个访问者类中，这有助于操作的封装和复用。

（3）双分派： 访问者模式通过对象的“接受”方法和访问者的“访问”方法实现了双分派，即运行时根据对象的实际类型和访问者的类型来确定执行的操作。

（4）灵活性： 访问者模式允许我们根据需要灵活地定义不同的访问者类，实现不同的操作逻辑。

（5）符合开闭原则： 访问者模式符合开闭原则，即对扩展开放，对修改封闭。当需要添加新的操作时，我们只需要添加新的访问者类，而不需要修改已有的数据结构。

然而，C++ 访问者模式也存在一些缺点：

（1）增加复杂性： 访问者模式增加了类的数量，使得系统变得更加复杂。每个元素类都需要实现接受方法，每个访问者类都需要实现访问方法，这可能导致代码量的增加。

（2）破坏封装性： 访问者模式要求元素类暴露其内部状态给访问者类，这可能会破坏元素的封装性。如果访问者类不恰当地使用这些内部状态，可能会导致错误或不可预见的行为。

（3）类型安全： 在访问者模式中，由于访问者类需要访问元素类的内部状态，因此需要确保类型安全。否则，可能会导致运行时错误。

（4）性能开销： 由于访问者模式涉及到双分派，因此在某些情况下可能会引入额外的性能开销。