Mediator

//Mediator  模式提供将对象间 的交互和通讯封装在一个类中，各个对象间的通信不必显势去声明和引用，大大降低了系统 的复杂性能
//
//例如 图中 ConcreteColleagueA 和 ConcreteColleagueB 之间的交互就可以通过 ConcreteMediator 提供的
//DoActionFromAtoB 来处理，ConcreteColleagueA 和 ConcreteColleagueB 不必维护对各自的引
//用，甚至它们也不知道各个的存在。Mediator通过这种方式将多对多的通信简化为了一 （Mediator ）对多（Colleague ）的通信。
//
//代码说明
//Mediator 模式的实现关键就是将对象 Colleague 之间的通信封装到一个类种单独处理，
//为了模拟 Mediator 模式的功能，这里给每个 Colleague 对象一个 string 型别以记录其状态，
//并通过状态改变来演示对象之间的交互和通信。这里主要就 Mediator                         的示例运行结果给出
//分析：
//     1 ）将ConcreteColleageA 对象设置状态“old ”，ConcreteColleageB 也设置状态“old ”；
//
//     2 ）ConcreteColleageA 对象改变状态，并在 Action 中和 ConcreteColleageB 对象进行通信，并改变 ConcreteColleageB 对象的状态为“new ”；
//
//     3 ）ConcreteColleageB 对象改变状态，并在 Action 中和 ConcreteColleageA 对象进行通信，并改变 ConcreteColleageA 对象的状态为“new ”；
//
//    注意到，两个 Colleague  对象并不知道它交互的对象，并且也不是显示地处理交互过程，这一切都是 通过 Mediator 对象完成的，示例程序运行的结
//果也正是证明了这一点。

//两个 Colleague  对象并不知道它交互的对象，并且也不是显示地处理交互过程，这一切都是 通过 Mediator 对象完成的，
//Mediator 模式的实现关键就是将对象 Colleague 之间的通信封装到一个类种单独处理，
//中介者模式

//通过在类A中引入中介者类 实现A子类——>中介者类的通信  在中介者类中引入A子类 实现中介者类——>A子类的通信
//将多对多的通信 转变成一对多
#include <string>
using namespace std;

class Mediator;

class Colleage //通信
{
public:
 virtual ~Colleage(){}
 virtual void Aciton() = 0;
    int a;
protected:
 Colleage(){}
 Colleage(Mediator* mdt){this->_mdt = mdt;}
 
 Mediator* _mdt;//桥梁模式--
};

class Mediator //抽象中介者
{
public:
 virtual ~Mediator(){}
 virtual void DoActionFromAtoB() = 0;
 virtual void DoActionFromBtoA() = 0;
protected:
 Mediator(){}
};

class ConcreteColleageA:public Colleage //通信A
{
public:
 ConcreteColleageA(){}
 ConcreteColleageA(Mediator* mdt,int t):Colleage(mdt){a = t;}//父类的成员变量不能在初始化列表初始化
 ~ConcreteColleageA(){}
 
 virtual void Aciton()
 {
  _mdt->DoActionFromAtoB();//中介者实现通信 
 } 
};

class ConcreteColleageB:public Colleage //通信B
{
public:
 ConcreteColleageB(){}
 ConcreteColleageB(Mediator* mdt,int t):Colleage(mdt){a = t;}
 ~ConcreteColleageB(){}
 
 virtual void Aciton()
 {
  _mdt->DoActionFromBtoA();
 }
};

 

class ConcreteMediator:public Mediator  //具体中介者 在此类实现AB通信
{
public:
 ConcreteMediator(){}
 ConcreteMediator(Colleage* clgA,Colleage* clgB):_clgA(clgA),_clgB(clgB){}
 ~ConcreteMediator(){}

 virtual void DoActionFromAtoB(){_clgB->a = _clgA->a;}

 virtual void DoActionFromBtoA(){_clgA->a = _clgB->a;}

 void SetConcreteColleageA(Colleage* clgA){this->_clgA = clgA;}

 void SetConcreteColleageB(Colleage* clgB){this->_clgB = clgB;}

 Colleage* GetConcreteColleageA(){return _clgA;}

 Colleage* GetConcreteColleageB(){return _clgB;}

private:
 Colleage* _clgA;
 Colleage* _clgB;
};

void Mediator_test()
{
 ConcreteMediator* m = new ConcreteMediator();
 ConcreteColleageA* c1 = new ConcreteColleageA(m,3);
 ConcreteColleageB* c2 = new ConcreteColleageB(m,4);
 m->SetConcreteColleageA(c2);
 m->SetConcreteColleageB(c2);
 
 c1->Aciton(); //B得到A数据  虽然是调用的A函数 实际却通过中介者来完成
 
 c2->Aciton(); //A得到B数据
}