行为模式---访问者模式

概念

访问者模式是设计模式行为模式的一种，主要是用于将算法和所作用的对象隔离开来。

访问者模式通过将算法封装在访问者对象中，使得算法可以独立于对象结构变化。对象结构中的每个元素都接受访问者对象，并将自身传递给访问者对象，从而执行操作。

适用场景

1、如果需要对一个复杂结构进行所有元素进行操作，而又不想去修改原始结构的时候，可以使用访问者模式。

2、如果在所作用的对象添加一些附加操作，而不能去修改所作用的对象结构的时候，可以使用访问者模式。

3、当一些行为在类的层次结构中的一些类有意义，而对于其他类没有意义的时候，可以使用此模式。

创建方式

1、创建一个访问者类，在此类中实现一系列的操作函数。

2、在被操作类中添加一个接口，用于接受访问者对象，并通过访问者对象去调用访问者的操作函数。

3、在客户端使用的时候创建访问者，并将访问者通过参数传递给被操作的类中。进行调用。

类关系图

示例代码

#include "FangWenZheMoShi.h"
int main()
{
    std::cout << "欢迎东哥来到设计模式的世界!\n";
    //创建访问者类对象
    VisitorInterFace* vistior1 = new ConcreteViritor1();
    VisitorInterFace* vistior2 = new ConcreteViritor2();
    //创建元素对象
    ConcreteItem1* item1 = new ConcreteItem1();
    item1->setVisitor(vistior1);
    item1->callVisitor();
    item1->setVisitor(vistior2);
    item1->callVisitor();
    cout << "==========================" << endl;
    ConcreteItem2* item2 = new ConcreteItem2();
    item2->setVisitor(vistior1);
    item2->callVisitor();
    item2->setVisitor(vistior2);
    item2->callVisitor();
}

#pragma once
#include <iostream>
#include <string>

using namespace std;

//访问者接口类
class VisitorInterFace
{
public:
	VisitorInterFace() {}
	~VisitorInterFace() {}
	virtual void handle1() {}
	virtual void handle2() {}
	string name;

};

//元素接口类
class FItemInterface
{
public:
	FItemInterface() {}
	~FItemInterface() {}
	VisitorInterFace* m_visitor;
	virtual void setVisitor(VisitorInterFace* visitor) {
		m_visitor = visitor;
	}
};

//具体访问者类1
class ConcreteViritor1 : public VisitorInterFace {
public:
	ConcreteViritor1() {
		name = "ConcreteViritor1";
	}
	~ConcreteViritor1() {}
	void handle1() {
		cout << "具体访问者1 ConcreteViritor1 的 handle1 函数" << endl;
	}
	void handle2() {
		cout << "具体访问者1 ConcreteViritor1 的 handle2 函数" << endl;
	}
};

//具体访问者类2
class ConcreteViritor2 : public VisitorInterFace {
public:
	ConcreteViritor2() {
		name = "ConcreteViritor2";
	}
	~ConcreteViritor2() {}
	void handle1() {
		cout << "具体访问者1 ConcreteViritor2 的 handle1 函数" << endl;
	}
	void handle2() {
		cout << "具体访问者1 ConcreteViritor2 的 handle2 函数" << endl;
	}
};

//具体的元素类
class ConcreteItem1 : public FItemInterface {
public:
	ConcreteItem1() {}
	~ConcreteItem1() {}
	void setVisitor(VisitorInterFace* visitor) {
		m_visitor = visitor;
	}
	void callVisitor() {
		if (m_visitor) {
			cout << "具体元素类1 ConcreteItem1 调用 "<< m_visitor->name << " 的handle1 函数" << endl;
			m_visitor->handle1();
		}
	}
};

//具体的元素类
class ConcreteItem2 : public FItemInterface {
public:
	ConcreteItem2() {}
	~ConcreteItem2() {}
	void setVisitor(VisitorInterFace* visitor) {
		m_visitor = visitor;
	}
	void callVisitor() {
		if (m_visitor) {
			m_visitor->handle2();
			cout << "具体元素类1 ConcreteItem2 调用 " << m_visitor->name << " 的handle2 函数" << endl;
		}
	}
};

欢迎东哥来到设计模式的世界!
具体元素类1 ConcreteItem1 调用 ConcreteViritor1 的handle1 函数
具体访问者1 ConcreteViritor1 的 handle1 函数
具体元素类1 ConcreteItem1 调用 ConcreteViritor2 的handle1 函数
具体访问者1 ConcreteViritor2 的 handle1 函数
==========================
具体访问者1 ConcreteViritor1 的 handle2 函数
具体元素类1 ConcreteItem2 调用 ConcreteViritor1 的handle2 函数
具体访问者1 ConcreteViritor2 的 handle2 函数
具体元素类1 ConcreteItem2 调用 ConcreteViritor2 的handle2 函数