对象行为模式——中介者模式（Mediator）

定义：用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。

说明：

1. Mediator 模式中，每个Colleague 维护一个 Mediator，当要进行通信时，每个具体的 Colleague 直接向ConcreteMediator 发信息，至于信息发到哪里，则由 ConcreteMediator 来决定。

2. ConcreteColleagueA 和 ConcreteColleagueB 不必维护对各自的引用，甚至它们也不知道各个的存在。

3. 优点是，各个 Colleague 减少了耦合。

4. 缺点是，由于 Mediator 控制了集中化，于是就把 Colleague 之间的交互复杂性变为了中介者的复杂性，也就是中介者会变的比任何一个 Colleague 都复杂。

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

class Mediator;
class Colleague
{
public:
	virtual ~Colleague(){};
	virtual void Action()=0;
	virtual void SetState(const string& sd)=0;
	virtual string GetState()=0;
protected:
	Colleague(){};
	Colleague(Mediator* mdt){this->m_mdt=mdt;};
	Mediator* m_mdt;
};
class ConcreteColleagueA:public Colleague
{
public:
	ConcreteColleagueA(){};
	ConcreteColleagueA(Mediator* mdt):Colleague(mdt){}
	~ConcreteColleagueA(){};
	void SetState(const string& sd){m_sd=sd;}
	string GetState(){return m_sd;}
	void Action();
private:
	string m_sd;
};
class ConcreteColleagueB:public Colleague
{
public:
	ConcreteColleagueB(){};
	ConcreteColleagueB(Mediator* mdt):Colleague(mdt){}
	~ConcreteColleagueB(){};
	void SetState(const string& sd){m_sd=sd;};
	string GetState(){return m_sd;}
	void Action();
private:
	string m_sd;
};
class Mediator
{
public:
	virtual ~Mediator(){};
	virtual void DoActionFromAtoB()=0;
	virtual void DoActionFromBtoA()=0;
protected:
	Mediator(){};
};
class ConcreteMediator:public Mediator
{
public:
	ConcreteMediator(){};
	ConcreteMediator(Colleague* ClA,Colleague* ClB){m_ClA=ClA;m_ClB=ClB;};
	~ConcreteMediator(){};
	void SetConA(Colleague* ClA){m_ClA=ClA;}
	void SetConB(Colleague* ClB){m_ClB=ClB;}
	Colleague* GetConA(){return m_ClA;}
	Colleague* GetConB(){return m_ClB;}
	void DoActionFromAtoB(){m_ClB->SetState(m_ClA->GetState());}
	void DoActionFromBtoA(){m_ClA->SetState(m_ClB->GetState());}
	void IntroColleague(Colleague* ClA,Colleague* ClB)
	{
		m_ClA=ClA;m_ClB=ClB;
	}
private:
	Colleague* m_ClA;
	Colleague* m_ClB; 
};
void ConcreteColleagueA::Action()
{
	m_mdt->DoActionFromAtoB();
	cout<<"CONB " << this->GetState()<<endl;
}
void ConcreteColleagueB::Action()
{
	m_mdt->DoActionFromBtoA();
	cout<<"CONA " << this->GetState()<<endl;
}
int main()
{
	ConcreteMediator* m=new ConcreteMediator();
	ConcreteColleagueA* c1=new ConcreteColleagueA(m);
	ConcreteColleagueB* c2=new ConcreteColleagueB(m);
	m->IntroColleague(c1,c2);
	c1->SetState("jackill");
	c1->Action();
	c2->SetState("rukawa");
	c2->Action();
	cout<<endl;
	c1->SetState("new");
	c1->Action();
	c2->Action();
	cout<<endl;
	return 0;
}