C++中介者模式（Mediator）

UML类图（仅供参考）如下：

中介者模式解决的问题：

用来降低多个对象和类之间的通信复杂性。这种模式提供了一个中介类，该类通常处理不同类之间的通信，并支持松耦合，使代码易于维护。用一个中介对象来封装一系列的对象交互，中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。对象与对象之间存在大量的关联关系，这样势必会导致系统的结构变得很复杂，同时若一个对象发生改变，我们也需要跟踪与之相关联的对象，同时做出相应的处理。

源码

#include <iostream>
#include <string>

// 同事类声明
class CColleague;

// 抽象中介者
class CMediator
{
public:
	CMediator() :m_pColleague1(NULL), m_pColleague2(NULL) {}

	// 中介者添加同事
	virtual void AddConlleague(CColleague *pColleague) = 0;

	// 中介者转发同事消息
	virtual void Send(const std::string &sMessage, CColleague *pColleague) = 0;

protected:
	// 假如只有两个同事(一般的,一个中介者只有两个同事)
	CColleague *m_pColleague1;
	CColleague *m_pColleague2;
};

// 抽象同事
class CColleague
{
public:
	CColleague(CMediator *pMediator) :m_pMediator(pMediator) {}

	// 同事发送信息
	virtual void Send(const std::string &sMessage) = 0;

	// 同事接收消息
	virtual void Recv(const std::string &sMessage) = 0;

protected:
	// 所有的同事都认识中介者
	CMediator *m_pMediator;
};

// 同事1
class CConcreteColleague1 :public CColleague
{
public:
	CConcreteColleague1(CMediator *pMediator) :CColleague(pMediator) {}

	// 通过中介者转发信息
	virtual void Send(const std::string &sMessage)
	{
		m_pMediator->Send(sMessage, this);
	}

	// 收到的消息是由中介者代收的
	virtual void Recv(const std::string &sMessage)
	{
		std::cout << "同事1收到的消息为:" << sMessage << std::endl;
	}
};

// 同事2
class CConcreteColleague2 :public CColleague
{
public:
	CConcreteColleague2(CMediator *pMediator) :CColleague(pMediator) {}

	// 通过中介者发送信息
	virtual void Send(const std::string &sMessage)
	{
		m_pMediator->Send(sMessage, this);
	}

	// 收到的消息是由中介者代收的
	virtual void Recv(const std::string &sMessage)
	{
		std::cout << "同事2收到的消息为:" << sMessage << std::endl;
	}
};

class CConcreteMediator :public CMediator 
{
public:

	// 中介者添加一个人事的同事
	virtual void AddConlleague(CColleague *pColleague)
	{
		if (NULL == m_pColleague1)
		{
			m_pColleague1 = pColleague;
		}
		else
		{
			m_pColleague2 = pColleague;
		}
	}

	// 中介者转发一个消息
	virtual void Send(const std::string &sMessage, CColleague *pColleague)
	{
		if (pColleague == m_pColleague1)
		{
			m_pColleague2->Recv(sMessage);
		}
		else
		{
			m_pColleague1->Recv(sMessage);
		}
	}
};

int main()
{
	CMediator *pMediator = new CConcreteMediator();
	CColleague *pColleague1 = new CConcreteColleague1(pMediator);
	CColleague *pColleague2 = new CConcreteColleague2(pMediator);

	pMediator->AddConlleague(pColleague1);
	pMediator->AddConlleague(pColleague2);

	pColleague1->Send("你好,我是1");
	pColleague2->Send("你好,我是2");

	return 0;
}

好处

1、降低了类的复杂度，将一对多转化成了一对一。

2、各个类之间的解耦。

3、符合迪米特原则