] view plain copy
 
 print?
  1. /* 
  2.     中介者模式：用一个中介对象来封装一系列的对象交互，中介者使各个对系那个不需要显示的相互引用， 
  3.     从而使其耦合松散，而且可以独立改变他们之间的交互。 
  4.  
  5.     在中介者模式中，通过创造出一个中介者对象，将系统中有关的对象所引用的其他对象数目减少到最少， 
  6.     使得一个对象与其同事之间的相互作用被这个对象与中介者对象之间的相互作用所取代。因此，中介者 
  7.     模式就是迪米特法则的一个典型应用。 
  8.  
  9.     Created by Phoenix_FuliMa 
  10. */  
  11. #include <iostream>  
  12. #include <string>  
  13. #include <vector>  
  14. using namespace std;  
  15.   
  16. class Colleague;  
  17. class Mediator  
  18. {  
  19. public:  
  20.     virtual void SendMsg(Colleague *_colleague) = 0;  
  21. };  
  22.   
  23. class Colleague  
  24. {  
  25. protected:  
  26.     Mediator *_mediator;  
  27.   
  28. public:  
  29.     Colleague(Mediator *mediator)  
  30.     {  
  31.         this->_mediator = mediator;  
  32.     }  
  33.   
  34.     virtual void Send()  
  35.     {   }  
  36.   
  37.     virtual void Notify()  
  38.     {  
  39.   
  40.     }  
  41. };  
  42.   
  43. class ConcreteColleague1:public Colleague  
  44. {  
  45. public:  
  46.     ConcreteColleague1(Mediator *mediator)  
  47.         :Colleague(mediator)  
  48.     {}  
  49.     void Notify()  
  50.     {  
  51.         cout<<"ConcreteColleague1 is notify..."<<endl;  
  52.     }  
  53.     void Send()  
  54.     {  
  55.         this->_mediator->SendMsg(this);  
  56.     }  
  57. };  
  58.   
  59. class ConcreteColleague2 :public Colleague  
  60. {  
  61. public:  
  62.     ConcreteColleague2(Mediator *mediator)  
  63.         :Colleague(mediator)  
  64.     {}  
  65.     void Notify()  
  66.     {  
  67.         cout<<"ConcreteColleague2 is notify..."<<endl;  
  68.     }  
  69.     void Send()  
  70.     {  
  71.         this->_mediator->SendMsg(this);  
  72.     }  
  73. };  
  74.   
  75. class ConcreteMediator: public Mediator  
  76. {  
  77. protected:  
  78.     vector<Colleague*> colleagues;  
  79.   
  80. public:  
  81.     void AddColleague(Colleague *colleague)  
  82.     {  
  83.         colleagues.push_back(colleague);  
  84.     }  
  85.     void SendMsg(Colleague *_colleague)  
  86.     {  
  87.         vector<Colleague*>::iterator iter = colleagues.begin();  
  88.         for(; iter != colleagues.end(); iter++)  
  89.         {  
  90.             if((*iter) == _colleague)  
  91.             {  
  92.                 _colleague->Notify();  
  93.                 break;  
  94.             }  
  95.         }  
  96.     }  
  97. };  
  98.   
  99. int main()  
  100. {  
  101.     ConcreteMediator* mediator = new ConcreteMediator();  
  102.   
  103.     ConcreteColleague1* colleague1 = new ConcreteColleague1(mediator);  
  104.     ConcreteColleague2* colleague2 = new ConcreteColleague2(mediator);  
  105.   
  106.   
  107.     mediator->AddColleague(colleague1);  
  108.     mediator->AddColleague(colleague2);  
  109.   
  110.     colleague1->Send();  
  111.     colleague2->Send();  
  112.   
  113.     delete colleague1;  
  114.     delete colleague2;  
  115.     delete mediator;  
  116.   
  117.     system("pause");  
  118.     return 0;  
  119. }