C++23种设计模式（22）-中介者模式

中介者模式：用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。中介者模式的例子很多，大到联合国安理会，小到房屋中介，都扮演了中间者的角色，协调各方利益。
本文就以租房为例子，如果没有房屋中介，那么房客要自己找房东，而房东也要自己找房客，非常不方便。有了房屋中介机构就方便了，房东可以把要出租的房屋信息放到中介机构，而房客可以去中介机构咨询。在软件中，就是多个对象之间需要通信，如果没有中介，对象就需要知道其他对象，最坏情况下，可能需要知道所有其他对象，而有了中介对象就方便多了，对象只需与中介对象通信，而不用知道其他的对象。

#include <iostream>
#include <list>
#include<vector>
#include<string>
using namespace std;

class Visitor;
// 被访问元素
class Element
{
protected:
	std::string m_strName;
public:
	Element(std::string str)
	{
		m_strName = str;
	}
	std::string getName()
	{
		return m_strName;
	}
	virtual void Accept(Visitor * visitor) = 0;
};

class ConcreteElementA : public Element
{
public:
	ConcreteElementA(std::string str) : Element(str) {}
	void Accept(Visitor * visitor);
};

class ConcreteElementB : public Element
{
public:
	ConcreteElementB(std::string str) : Element(str) {}
	void Accept(Visitor * visitor);
};

// 访问者
class Visitor
{
public:
	virtual void VisitConcreteElementA(ConcreteElementA * p) = 0;
	virtual void VisitConcreteElementB(ConcreteElementB * p) = 0;
};

class ConcreteVisitorA : public Visitor
{
public:
	void VisitConcreteElementA(ConcreteElementA * p)
	{
		std::cout << "ConcreteVisitorA 访问了" << p->getName() << std::endl;
	}
	void VisitConcreteElementB(ConcreteElementB * p)
	{
		std::cout << "ConcreteVisitorA 访问了" << p->getName() << std::endl;
	}
};

class ConcreteVisitorB : public Visitor
{
public:
	void VisitConcreteElementA(ConcreteElementA * p)
	{
		std::cout << "ConcreteVisitorB 访问了" << p->getName() << std::endl;
	}
	void VisitConcreteElementB(ConcreteElementB * p)
	{
		std::cout << "ConcreteVisitorB 访问了" << p->getName() << std::endl;
	}
};

void ConcreteElementA::Accept(Visitor * visitor)
{
	visitor->VisitConcreteElementA(this);
}
void ConcreteElementB::Accept(Visitor * visitor)
{
	visitor->VisitConcreteElementB(this);
}
// 聚集类
class ObjectStructure
{
private:
	std::vector<Element *> m_vec;
public:
	~ObjectStructure()
	{
		for (auto it = m_vec.begin(); it != m_vec.end(); it++)
		{
			delete *it;
		}
		m_vec.clear();
	}
	void add(Element * p)
	{
		m_vec.push_back(p);
	}
	void accept(Visitor * visitor)
	{
		for (auto it = m_vec.cbegin(); it != m_vec.cend(); it++)
		{
			(*it)->Accept(visitor);
		}
	}
};


int main()
{
	using namespace std;
	// 访问者模式
	ObjectStructure * p = new ObjectStructure();
	p->add(new ConcreteElementA("A"));
	p->add(new ConcreteElementB("B"));

	ConcreteVisitorA * pVisitorA = new ConcreteVisitorA();
	ConcreteVisitorB * pVisitorB = new ConcreteVisitorB();

	p->accept(pVisitorA);
	p->accept(pVisitorB);

	delete pVisitorA;
	delete pVisitorB;
	delete p;

	getchar();
	return 0;
}