目录
前言：
访问者模式是一种行为型设计模式，它允许你定义一个新的操作，而无需改变元素类。这种模式的核心思想是将数据结构和对数据结构的操作分离开来，从而可以在不改变数据结构的前提下，定义新的操作。
访问者模式的关键是双重分派。在访问者模式中，元素类中会定义一个接受访问者的方法，而访问者类中会定义对应于不同元素的操作方法。当一个访问者对象访问一个元素对象时，会根据元素对象的类型和访问者对象的类型，动态地调用对应的操作方法，从而实现了双重分派。
通过使用访问者模式，可以很方便地增加新的操作，而不需要修改元素类。这使得访问者模式在处理数据结构中的元素类型和访问者的操作都可能发生变化的情况下非常有用。例如，在编译器的语法树分析、文件系统的遍历等场景中，访问者模式可以帮助我们方便地增加新的操作而不影响原有的数据结构。
总之，访问者模式通过将操作封装到访问者类中，实现了对数据结构的操作与数据结构本身的分离，从而使得可以方便地定义新的操作而不影响原有的数据结构。
一、原理及示例代码：
访问者模式是一种行为设计模式，它允许你在不改变对象结构的前提下定义新操作。这意味着你可以在不修改现有代码的情况下向现有对象结构中添加新操作。访问者模式适用于需要对对象结构中的元素进行多种不同操作的场景。
在访问者模式中，有两个主要角色：访问者（Visitor）和元素（Element）。访问者定义了对元素进行操作的接口，而元素则提供了接受访问者的方法。当一个访问者访问一个元素时，元素会调用访问者的特定方法来执行操作。
下面是一个简单的C++示例代码，演示了访问者模式的实现：
#include <iostream>
#include <vector>
// 前向声明
class ElementB;
// 访问者接口
class Visitor {
public:
virtual void visitElementA(ElementA& elementA) = 0;
virtual void visitElementB(ElementB& elementB) = 0;
};
// 元素接口
class Element {
public:
virtual void accept(Visitor& visitor) = 0;
};
// 具体元素A
class ElementA : public Element {
public:
void accept(Visitor& visitor) override {
visitor.visitElementA(*this);
}
void operationA() {
std::cout << "Operation A on Element A" << std::endl;
}
};
// 具体元素B
class ElementB : public Element {
public:
void accept(Visitor& visitor) override {
visitor.visitElementB(*this);
}
void operationB() {
std::cout << "Operation B on Element B" << std::endl;
}
};
// 具体访问者
class ConcreteVisitor : public Visitor {
public:
void visitElementA(ElementA& elementA) override {
elementA.operationA();
}
void visitElementB(ElementB& elementB) override {
elementB.operationB();
}
};
int main() {
// 创建元素
ElementA elementA;
ElementB elementB;
// 创建访问者
ConcreteVisitor visitor;
// 访问元素
elementA.accept(visitor);
elementB.accept(visitor);
return 0;
}
在上面的示例中，访问者模式被用于对两种不同的元素（ElementA和ElementB）执行不同的操作。访问者（ConcreteVisitor）定义了对这些元素的操作，而元素则提供了接受访问者的方法（accept）。当访问者访问元素时，元素会调用访问者的特定方法来执行操作。
二、结构图：
访问者模式的结构图包括以下几个主要元素：
-
Visitor（访问者）：定义了对元素进行操作的接口，包括多个访问不同类型元素的方法。
-
ConcreteVisitor（具体访问者）：实现了Visitor接口，提供了对具体元素的操作方法。
-
Element（元素）：定义了接受访问者的接口，通常包括一个accept方法，用于将访问者传递给元素。
-
ConcreteElement（具体元素）：实现了Element接口，提供了accept方法的具体实现。
-
ObjectStructure（对象结构）：维护了一个元素的集合，并且可以让访问者访问这些元素。
下面是访问者模式的结构图示例：
+-------------------+
| Visitor |<-----------------+
+-------------------+ |
| visitConcreteElementA() |
| visitConcreteElementB() |
+-------------------+ |
^ |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
+-------------------+ |
| ConcreteVisitor | |
+-------------------+ |
| visitConcreteElementA() |
| visitConcreteElementB() |
+-------------------+ |
^ |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
+-------------------+ |
| Element | |
+-------------------+ |
| accept(Visitor) | |
+-------------------+ |
^ |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
+-------------------+ |
| ConcreteElement | |
+-------------------+ |
| accept(Visitor) | |
+-------------------+ |
^ |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
+-------------------+ |
| ObjectStructure | |
+-------------------+ |
| elements | |
| attach(Element) | |
| detach(Element) | |
| accept(Visitor) | |
+-------------------+ |三、使用场景：
访问者模式通常在以下情况下使用：
-
当一个对象结构包含多个不同类型的对象，并且需要对这些对象执行不同的操作时，可以使用访问者模式。访问者模式允许将操作从对象结构中分离出来，并将其封装在访问者类中。
-
当需要在不修改对象结构的情况下，添加新的操作或行为到对象中时，可以使用访问者模式。通过添加新的访问者类，可以实现新的操作，而无需修改现有的对象结构。
-
当对象结构中的对象类型相对稳定，但经常需要添加新的操作时，可以使用访问者模式。访问者模式使得添加新的操作变得简单，只需要创建新的访问者类即可。
-
当对象结构中的对象类型很少改变，但经常需要在这些对象上执行复杂操作时，可以使用访问者模式。访问者模式可以将复杂的操作分离出来，使得对象结构更加清晰和简单。
总的来说，访问者模式适用于需要对一个稳定的对象结构执行多种不同操作的情况，以及需要在不修改对象结构的情况下，添加新的操作或行为的情况。
场景1：
当一个对象结构包含多个不同类型的对象，并且需要对这些对象执行不同的操作时。
#include <iostream>
#include <vector>
// 前向声明
class ConcreteElementA;
class ConcreteElementB;
// 访问者接口
class Visitor {
public:
virtual void visitConcreteElementA(ConcreteElementA* element) = 0;
virtual void visitConcreteElementB(ConcreteElementB* element) = 0;
};
// 具体访问者
class ConcreteVisitor : public Visitor {
public:
void visitConcreteElementA(ConcreteElementA* element) override {
std::cout << "ConcreteVisitor is visiting ConcreteElementA" << std::endl;
}
void visitConcreteElementB(ConcreteElementB* element) override {
std::cout << "ConcreteVisitor is visiting ConcreteElementB" << std::endl;
}
};
// 元素接口
class Element {
public:
virtual void accept(Visitor* visitor) = 0;
};
// 具体元素A
class ConcreteElementA : public Element {
public:
void accept(Visitor* visitor) override {
visitor->visitConcreteElementA(this);
}
};
// 具体元素B
class ConcreteElementB : public Element {
public:
void accept(Visitor* visitor) override {
visitor->visitConcreteElementB(this);
}
};
// 对象结构
class ObjectStructure {
private:
std::vector<Element*> elements;
public:
void attach(Element* element) {
elements.push_back(element);
}
void detach(Element* element) {
// 省略实现
}
void accept(Visitor* visitor) {
for (Element* element : elements) {
element->accept(visitor);
}
}
};
int main() {
ConcreteVisitor* visitor = new ConcreteVisitor();
ObjectStructure* objectStructure = new ObjectStructure();
objectStructure->attach(new ConcreteElementA());
objectStructure->attach(new ConcreteElementB());
objectStructure->accept(visitor);
delete visitor;
delete objectStructure;
return 0;
}
在这个示例中，我们定义了Visitor接口和ConcreteVisitor具体访问者类，以及Element接口和具体元素类ConcreteElementA和ConcreteElementB。然后我们定义了对象结构ObjectStructure，用于维护元素的集合，并实现了访问者模式的核心方法accept。在main函数中，我们创建了具体访问者和对象结构，并将具体元素添加到对象结构中，然后通过对象结构的accept方法让具体访问者访问这些元素。
场景2：
在不修改对象结构的情况下，添加新的操作或行为到对象中。
#include <iostream>
#include <vector>
// 前向声明
class Element;
// 访问者接口
class Visitor {
public:
virtual void visit(Element* 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);
}
};
// 具体元素B
class ConcreteElementB : public Element {
public:
void accept(Visitor* visitor) override {
visitor->visit(this);
}
};
// 具体访问者
class ConcreteVisitor : public Visitor {
public:
void visit(Element* element) override {
if (dynamic_cast<ConcreteElementA*>(element)) {
std::cout << "ConcreteVisitor is visiting ConcreteElementA" << std::endl;
} else if (dynamic_cast<ConcreteElementB*>(element)) {
std::cout << "ConcreteVisitor is visiting ConcreteElementB" << std::endl;
}
}
};
int main() {
ConcreteVisitor* visitor = new ConcreteVisitor();
std::vector<Element*> elements = {new ConcreteElementA(), new ConcreteElementB()};
for (Element* element : elements) {
element->accept(visitor);
}
delete visitor;
for (Element* element : elements) {
delete element;
}
return 0;
}
在这个示例中，我们定义了Visitor接口和ConcreteVisitor具体访问者类，以及Element接口和具体元素类ConcreteElementA和ConcreteElementB。在具体访问者的visit方法中，我们使用dynamic_cast来判断具体访问者访问的是哪种具体元素，并执行相应的操作。
在main函数中，我们创建了具体访问者和具体元素的集合，并通过访问者模式实现了对元素的访问和操作。
场景3：
访问者的操作可能会发生变化。
#include <iostream>
#include <vector>
// 前向声明
class Element;
// 访问者接口
class Visitor {
public:
virtual void visit(Element* 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);
}
};
// 具体元素B
class ConcreteElementB : public Element {
public:
void accept(Visitor* visitor) override {
visitor->visit(this);
}
};
// 具体访问者
class ConcreteVisitor : public Visitor {
public:
void visit(Element* element) override {
std::cout << "ConcreteVisitor is visiting an element" << std::endl;
}
};
// 具体访问者的另一种实现
class AnotherConcreteVisitor : public Visitor {
public:
void visit(Element* element) override {
std::cout << "AnotherConcreteVisitor is visiting an element" << std::endl;
}
};
int main() {
ConcreteVisitor* visitor1 = new ConcreteVisitor();
AnotherConcreteVisitor* visitor2 = new AnotherConcreteVisitor();
std::vector<Element*> elements = {new ConcreteElementA(), new ConcreteElementB()};
for (Element* element : elements) {
element->accept(visitor1);
element->accept(visitor2);
}
delete visitor1;
delete visitor2;
for (Element* element : elements) {
delete element;
}
return 0;
}
在这个示例中，我们定义了Visitor接口和ConcreteVisitor、AnotherConcreteVisitor具体访问者类，以及Element接口和具体元素类ConcreteElementA和ConcreteElementB。在main函数中，我们创建了两个不同的具体访问者，并对同一个对象结构中的元素进行访问。这样，我们可以看到不同的访问者对相同的元素执行不同的操作。
场景4：
对象结构的元素类型和访问者的操作都可能发生变化。
#include <iostream>
#include <vector>
// 前向声明
class Element;
// 访问者接口
class Visitor {
public:
virtual void visit(Element* 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);
}
};
// 具体元素B
class ConcreteElementB : public Element {
public:
void accept(Visitor* visitor) override {
visitor->visit(this);
}
};
// 具体访问者
class ConcreteVisitor : public Visitor {
public:
void visit(Element* element) override {
if (dynamic_cast<ConcreteElementA*>(element)) {
std::cout << "ConcreteVisitor is visiting ConcreteElementA" << std::endl;
} else if (dynamic_cast<ConcreteElementB*>(element)) {
std::cout << "ConcreteVisitor is visiting ConcreteElementB" << std::endl;
}
}
};
int main() {
ConcreteVisitor* visitor = new ConcreteVisitor();
std::vector<Element*> elements = {new ConcreteElementA(), new ConcreteElementB()};
for (Element* element : elements) {
element->accept(visitor);
}
delete visitor;
for (Element* element : elements) {
delete element;
}
return 0;
}
在这个示例中，我们定义了Visitor接口和ConcreteVisitor具体访问者类，以及Element接口和具体元素类ConcreteElementA和ConcreteElementB。在具体访问者的visit方法中，我们使用dynamic_cast来判断具体访问者访问的是哪种具体元素，并执行相应的操作。
在main函数中，我们创建了具体访问者和具体元素的集合，并通过访问者模式实现了对元素的访问和操作。
四、优缺点
访问者模式是一种行为型设计模式，它将数据结构和对数据结构的操作分离开来，使得可以在不改变数据结构的前提下，定义新的操作。访问者模式有以下优点和缺点：
优点：
- 增加新的操作很方便：通过添加新的访问者类，可以很容易地增加新的操作，而无需修改现有的对象结构。
- 将相关行为集中到访问者类中：访问者模式可以将相关的操作集中到访问者类中，使得代码更易于维护和扩展。
- 符合开闭原则：访问者模式使得增加新的操作符合开闭原则，即对扩展开放，对修改关闭。
缺点：
- 增加新的元素类困难：如果需要增加新的元素类，那么需要修改所有的访问者类，这违反了开闭原则。
- 增加新的访问者类困难：如果需要增加新的访问者类，那么需要修改所有的元素类，这同样违反了开闭原则。
- 违反单一职责原则：访问者模式将操作集中到访问者类中，可能导致访问者类变得庞大，违反了单一职责原则。
总的来说，访问者模式适用于当对象结构中的元素类型和操作都可能发生变化时，可以方便地添加新的操作而不影响现有的对象结构。然而，如果对象结构或操作的变化频繁，可能会导致访问者模式的维护成本增加。因此，在使用访问者模式时需要权衡利弊，根据具体的需求和场景来决定是否使用该模式。
五、常见面试题：
当面试官询问关于访问者模式的问题时，你可以参考以下答案解析：
-
什么是访问者模式？ 答案解析：访问者模式是一种行为型设计模式，它允许在不改变元素类的情况下定义新的操作。它将数据结构和对数据结构的操作分离开来，使得可以在不改变数据结构的前提下，定义新的操作。
-
访问者模式的主要角色有哪些？ 答案解析：访问者模式的主要角色包括抽象访问者（Visitor）、具体访问者（ConcreteVisitor）、抽象元素（Element）、具体元素（ConcreteElement）、对象结构（Object Structure）。
-
访问者模式的优点是什么？ 答案解析：访问者模式的优点包括增加新的操作很方便、将相关行为集中到访问者类中、符合开闭原则。
-
访问者模式的缺点是什么？ 答案解析：访问者模式的缺点包括增加新的元素类困难、增加新的访问者类困难、违反单一职责原则。
-
访问者模式和其他设计模式有什么区别？ 答案解析：访问者模式主要用于处理数据结构中的元素，而其他设计模式可能侧重于其他方面，如对象的创建、行为的封装等。
-
访问者模式适用于哪些场景？ 答案解析：访问者模式适用于对象结构中的元素类型和访问者的操作都可能发生变化的场景。
-
访问者模式如何实现对对象结构的访问和操作？ 答案解析：访问者模式通过在元素类中添加接受访问者的方法，以及在访问者类中实现对各种元素的操作方法，实现对对象结构的访问和操作。
-
访问者模式和多态有何关系？ 答案解析：访问者模式利用了双重分派，结合了元素的多态性和访问者的多态性，实现了对不同元素的不同操作。
-
访问者模式在实际项目中的应用场景有哪些？ 答案解析：访问者模式适用于解决数据结构中的元素类型和访问者的操作都可能发生变化的情况，例如编译器的语法树分析、文件系统的遍历等。
-
在访问者模式中，如何处理新的元素类型和新的操作的添加？ 答案解析：可以通过添加新的具体元素类和新的具体访问者类，以及在访问者类中实现新的操作方法，来处理新的元素类型和新的操作的添加。
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
