设计模式 22 访问者模式 Visitor Pattern
1.定义
访问者模式是一种行为型设计模式，它允许你在不改变已有类结构的情况下，为一组对象添加新的操作。它将算法与对象结构分离，使你能够在不修改现有类的情况下，为这些类添加新的操作。
2.内涵
访问者模式核心概念，有以下几点：
- 访问者 (Visitor): 定义了一个访问具体元素的方法，每个方法对应一个具体元素类。
- 具体访问者 (ConcreteVisitor): 实现访问者接口，定义对具体元素类的访问逻辑。
- 元素 (Element): 定义一个 accept 方法，接受访问者对象并调用访问者的 visit 方法。
- 具体元素 (ConcreteElement): 实现元素接口，提供访问者访问其内部状态的方法。
相关UML 图如下所示：
解释：
- Visitor 接口：定义了
visit方法，接受一个Element对象作为参数。 - ConcreteVisitor 类：实现了
Visitor接口，并定义了对Element对象的具体操作逻辑。 - Element 接口：定义了
accept方法，接受一个Visitor对象作为参数，并调用访问者的visit方法。 - ConcreteElement 类：实现了
Element接口，并提供operation方法，用于访问其内部状态。
3.案例分析
/**
* The Visitor Interface declares a set of visiting methods that correspond to
* component classes. The signature of a visiting method allows the visitor to
* identify the exact class of the component that it's dealing with.
*/
class ConcreteComponentA;
class ConcreteComponentB;
class Visitor {
public:
virtual void VisitConcreteComponentA(const ConcreteComponentA *element) const = 0;
virtual void VisitConcreteComponentB(const ConcreteComponentB *element) const = 0;
};
/**
* The Component interface declares an `accept` method that should take the base
* visitor interface as an argument.
*/
class Component {
public:
virtual ~Component() {}
virtual void Accept(Visitor *visitor) const = 0;
};
/**
* Each Concrete Component must implement the `Accept` method in such a way that
* it calls the visitor's method corresponding to the component's class.
*/
class ConcreteComponentA : public Component {
/**
* Note that we're calling `visitConcreteComponentA`, which matches the
* current class name. This way we let the visitor know the class of the
* component it works with.
*/
public:
void Accept(Visitor *visitor) const override {
visitor->VisitConcreteComponentA(this);
}
/**
* Concrete Components may have special methods that don't exist in their base
* class or interface. The Visitor is still able to use these methods since
* it's aware of the component's concrete class.
*/
std::string ExclusiveMethodOfConcreteComponentA() const {
return "A";
}
};
class ConcreteComponentB : public Component {
/**
* Same here: visitConcreteComponentB => ConcreteComponentB
*/
public:
void Accept(Visitor *visitor) const override {
visitor->VisitConcreteComponentB(this);
}
std::string SpecialMethodOfConcreteComponentB() const {
return "B";
}
};
/**
* Concrete Visitors implement several versions of the same algorithm, which can
* work with all concrete component classes.
*
* You can experience the biggest benefit of the Visitor pattern when using it
* with a complex object structure, such as a Composite tree. In this case, it
* might be helpful to store some intermediate state of the algorithm while
* executing visitor's methods over various objects of the structure.
*/
class ConcreteVisitor1 : public Visitor {
public:
void VisitConcreteComponentA(const ConcreteComponentA *element) const override {
std::cout << element->ExclusiveMethodOfConcreteComponentA() << " + ConcreteVisitor1\n";
}
void VisitConcreteComponentB(const ConcreteComponentB *element) const override {
std::cout << element->SpecialMethodOfConcreteComponentB() << " + ConcreteVisitor1\n";
}
};
class ConcreteVisitor2 : public Visitor {
public:
void VisitConcreteComponentA(const ConcreteComponentA *element) const override {
std::cout << element->ExclusiveMethodOfConcreteComponentA() << " + ConcreteVisitor2\n";
}
void VisitConcreteComponentB(const ConcreteComponentB *element) const override {
std::cout << element->SpecialMethodOfConcreteComponentB() << " + ConcreteVisitor2\n";
}
};
/**
* The client code can run visitor operations over any set of elements without
* figuring out their concrete classes. The accept operation directs a call to
* the appropriate operation in the visitor object.
*/
void ClientCode(std::array<const Component *, 2> components, Visitor *visitor) {
// ...
for (const Component *comp : components) {
comp->Accept(visitor);
}
// ...
}
int main() {
std::array<const Component *, 2> components = {new ConcreteComponentA, new ConcreteComponentB};
std::cout << "The client code works with all visitors via the base Visitor interface:\n";
ConcreteVisitor1 *visitor1 = new ConcreteVisitor1;
ClientCode(components, visitor1);
std::cout << "\n";
std::cout << "It allows the same client code to work with different types of visitors:\n";
ConcreteVisitor2 *visitor2 = new ConcreteVisitor2;
ClientCode(components, visitor2);
for (const Component *comp : components) {
delete comp;
}
delete visitor1;
delete visitor2;
return 0;
}输出：
The client code works with all visitors via the base Visitor interface:
A + ConcreteVisitor1
B + ConcreteVisitor1
It allows the same client code to work with different types of visitors:
A + ConcreteVisitor2
B + ConcreteVisitor2上述代码类之间关系 UML图，如下所示
4.注意事项
访问者模式在实施过程中，需要考虑以下几个方面，以确保代码的正确性、可维护性和可扩展性：
5.最佳实践
访问者模式是一种强大的工具，但使用不当会导致代码复杂化或破坏封装性。以下是一些最佳实践，帮助你有效地使用访问者模式：
6.总结
访问者模式是一种强大的设计模式，但需要谨慎使用。在实施访问者模式时，需要仔细考虑元素接口和访问者接口的设计，以及具体访问者类的实现。同时，需要了解访问者模式的局限性，并选择合适的应用场景。
