一、原理讲解

1.1意图

表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。

1.2应用场景

• 一个对象结构包含很多类对象，它们有不同的接口，而你想对这些对象实施一些依赖于其具体类的操作；
• 需要对一个对象结构中的对象进行很多不同并且不相关的操作，而你想避免这些操作“污染”这些对象的类；
• 定义对象结构的类很少改变，但经常需要在此结构定义新的操作；

1.3结构图（UML图）

1.4代码实现步骤

a1 定义接口访问者类Visitor，定义两个访问接口函数visitorElementA()、visitorElementB()；
a2 定义两个具体访问者类Visitor1、Visitor2，重写接口函数visitorElementA()、visitorElementB()，通过这两个函数去访问具体的对象elementA和elementB；
a3 定义一个原件类Element，定义一个接收函数accept(Visitor* visitor)接口；
a4 定义两个具体原件类ElementA、ElementB，重写accept()接口和定义一个功能函数operationA()或operationB()；
a5 定义一个类objectStruct，里面组合多个原件，然后用accept()访问每个原件；

二、实现代码

VisitorPattern.cpp

#include<iostream>
#include <vector>

using namespace std;

#define DELETE(pointer) delete (pointer); (pointer)=nullptr

class ElementA;
class ElementB;

class Visitor //抽象访问者
{
public:
	virtual ~Visitor() {}

	virtual void visitorElementA(ElementA *elementA) = 0;
	virtual void visitorElementB(ElementB *elementB) = 0;
};

class Visitor1 : public Visitor
{
public:
	void visitorElementA(ElementA *elementA) override;
	void visitorElementB(ElementB *elementB) override;
};

class Visitor2 : public Visitor
{
public:
	void visitorElementA(ElementA *elementA) override;
	void visitorElementB(ElementB *elementB) override;
};

class Element
{
public:
	virtual ~Element() {}

	virtual void accept(Visitor *visitor) = 0;
};

class ElementA : public Element
{
public:
	void accept(Visitor *visitor) override { visitor->visitorElementA(this); }

	void operation() { cout << "ElementA::operation()" << endl; }
};

class ElementB : public Element
{
public:
	void accept(Visitor *visitor) override { visitor->visitorElementB(this); }

	void operation() { cout << "ElementB::operation()" << endl; }
};

void Visitor1::visitorElementA(ElementA *elementA) 
{ 
	cout << "Visitor1::visitorElementA()" << endl; 
	elementA->operation(); 
}

void Visitor1::visitorElementB(ElementB *elementB) 
{ 
	cout << "Visitor1::visitorElementB()" << endl;
	elementB->operation(); 
}

void Visitor2::visitorElementA(ElementA *elementA) 
{ 
	cout << "Visitor2::visitorElementA()" << endl;
	elementA->operation(); 
}

void Visitor2::visitorElementB(ElementB *elementB) 
{ 
	cout << "Visitor2::visitorElementB()" << endl;
	elementB->operation(); 
}

class StructObject
{
public:
	void pushElement(Element *element) { elements.push_back(element); }
	void removeElement(Element *element)
	{
		auto it = std::find(elements.begin(), elements.end(), element);
		if (it != elements.end())
		{
			elements.erase(it);
		}
	}
	void accept(Visitor *visitor)
	{
		for (auto *element : elements)
		{
			element->accept(visitor);
		}
	}

private:
	vector<Element*> elements;
};

void doVisitorPattern()
{
	ElementA *elementA = new ElementA();
	ElementB *elementB = new ElementB();
	Visitor1 *visitor1 = new Visitor1();
	Visitor2 *visitor2 = new Visitor2();
	StructObject *object = new StructObject();

	// 访问者visitor1访问原件ElementA、ElementB里面内容，比如operation()
	object->pushElement(elementA);
	object->pushElement(elementB);
	object->accept(visitor1);

	// 访问者visitor2访问原件ElementB里面内容，比如operation()
	cout << "\n------------------------ delete one element ------------------------" << endl;
	object->removeElement(elementA);
	object->accept(visitor2);

	DELETE(visitor2);
	DELETE(visitor1);
	DELETE(elementB);
	DELETE(elementA);
}

mian.cpp

#include <iostream>

extern void doVisitorPattern();

int main()
{
	doVisitorPattern();
	
	system("pause");
	return 1;
}

三、总结

访问者模式的核心思想是用一个访问者对象访问目标对象的成员函数或者成员变量，前提是不改变目标类的结构。代码实现的核心思想是在访问者类Visitor通过接口函数Visitor::visitorElement(ElementA*)访问目标对象成员函数，然后目标类Element通过接口函数Element::accept(Visitor* visitor){visitor->visitorElementA(this);}反射自动化调用访问自身并且将自身指针this传递给访问者访问接口Visitor::visitorElement(this)。

3.1相关模式

• Composite：访问者可以用于对一个由Composite模式定义的对象结构进行操作；
• Interpreter：访问者可以用于解释；

四、参考内容

设计模式(17) 访问者模式(VISITOR) C++实现
访问者模式 c++ boost
C++设计模式——访问者模式
陈建忠设计模式（参考：哔哩哔哩C++设计模式！！！）
Erich Gamma,Richard Helm.《设计模式 可复用面向对象软件的基础》[M].机械工业出版社,2019: