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)性能开销: 由于访问者模式涉及到双分派,因此在某些情况下可能会引入额外的性能开销。