设计模式-行为-中介者

#pragma once

//#ifndef _COLLEAGE_H_
//#define _COLLEAGE_H_
#include <string>

using namespace std;
class Mediator;
class Colleage
{
public:
  virtual ~Colleage();
  virtual void Aciton() = 0;
  virtual void SetState(const string& sdt) = 0;
  virtual string GetState() = 0;
protected:
  Colleage();
  Colleage(Mediator* mdt);
  Mediator* _mdt;
private:
};
class ConcreteColleageA:public Colleage
{
public:
  ConcreteColleageA();
  ConcreteColleageA(Mediator* mdt);
  ~ConcreteColleageA();
  void Aciton();
  void SetState(const string& sdt);
  string GetState();
protected:
private:
  string _sdt;
};
class ConcreteColleageB:public Colleage
{
public:
  ConcreteColleageB();
  ConcreteColleageB(Mediator* mdt);
  ~ConcreteColleageB();
  void Aciton();
  void SetState(const string& sdt);
  string GetState();
protected:
private:
  string _sdt;
};
//#endif //~_COLLEAGE_H_

//Mediator.h
//#ifndef _MEDIATOR_H_
//#define _MEDIATOR_H_
class Colleage;
class Mediator
{
public:
  virtual ~Mediator();
  virtual void DoActionFromAtoB() = 0;
  virtual void DoActionFromBtoA() = 0;
protected:
  Mediator();
private:
};
class ConcreteMediator:public Mediator
{
public:
  ConcreteMediator();
  ConcreteMediator(Colleage* clgA,Colleage* clgB);
  ~ConcreteMediator();
  void  SetConcreteColleageA(Colleage* clgA);
  void  SetConcreteColleageB(Colleage* clgB);
  Colleage* GetConcreteColleageA();
  Colleage* GetConcreteColleageB();
  void  IntroColleage(Colleage* clgA,Colleage* clgB);
  void DoActionFromAtoB();
  void DoActionFromBtoA();
protected:
private:
  Colleage* _clgA;
  Colleage* _clgB;
};
//#endif //~_MEDIATOR_H

#include "StdAfx.h"
#include "mediator_impl.h"

//Colleage.cpp
#include <iostream>
using namespace std;

Colleage::Colleage()
{

}
Colleage::Colleage(Mediator* mdt)
{ 
  this->_mdt = mdt;
}
Colleage::~Colleage()
{

}
ConcreteColleageA::ConcreteColleageA()
{
}
ConcreteColleageA::~ConcreteColleageA()
{

}
ConcreteColleageA::ConcreteColleageA(Mediator* mdt)
:Colleage(mdt) 
{
}
string ConcreteColleageA::GetState()
{ 
  return _sdt; 
}
void  ConcreteColleageA::SetState(const string& sdt)
{ 
  _sdt = sdt;
}
void ConcreteColleageA::Aciton()
{
  _mdt->DoActionFromAtoB();
  cout<<"State of ConcreteColleageB:"<<" "<<this->GetState()<<endl;
}
ConcreteColleageB::ConcreteColleageB()
{

}
ConcreteColleageB::~ConcreteColleageB()
{

}
ConcreteColleageB::ConcreteColleageB(Mediator* mdt):Colleage(mdt)
{

}
void ConcreteColleageB::Aciton()
{
  _mdt->DoActionFromBtoA();
  cout<<"State  of  ConcreteColleageB:"<<" "<<this->GetState()<<endl;
}
string ConcreteColleageB::GetState()
{ 
  return _sdt; }

void  ConcreteColleageB::SetState(const string& sdt)
{ 
  _sdt = sdt; 
}


//Mediator.cpp
Mediator::Mediator()
{
}
Mediator::~Mediator()
{
}
ConcreteMediator::ConcreteMediator()
{

}
ConcreteMediator::~ConcreteMediator()
{

}
ConcreteMediator::ConcreteMediator(Colleage* clgA,Colleage* clgB)
{  
  this->_clgA = clgA;
  this->_clgB = clgB;
}

void ConcreteMediator::DoActionFromAtoB()
{ 
  _clgB->SetState(_clgA->GetState()); 
}
void ConcreteMediator::SetConcreteColleageA(Colleage* clgA)
{ 
  this->_clgA = clgA; 
}
void ConcreteMediator::SetConcreteColleageB(Colleage* clgB)
{ 
  this->_clgB = clgB; 
}
Colleage* ConcreteMediator::GetConcreteColleageA()
{ 
  return _clgA; 
}
Colleage* ConcreteMediator::GetConcreteColleageB()
{ 
  return _clgB; 
}
void ConcreteMediator::IntroColleage(Colleage* clgA,Colleage* clgB)
{  
  this->_clgA = clgA;
  this->_clgB = clgB;
}
void ConcreteMediator::DoActionFromBtoA()
{
  _clgA->SetState(_clgB->GetState());
}

// Mediator.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"

#include "mediator_impl.h"
#include <stdlib.h>
#include <iostream>
using namespace std;
//用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地相互引用，
//从而使其耦合松散，而且可以独立地改变它们之间的交互。
int _tmain(int argc, _TCHAR* argv[])
{
  // A<---->Mediator<---->B
  ConcreteMediator*  m  =  new ConcreteMediator();
  ConcreteColleageA*  c1  =  new ConcreteColleageA(m);
  ConcreteColleageB*  c2  =  new ConcreteColleageB(m);
  m->IntroColleage(c1,c2);//中介者关联A和B
  c1->SetState("old");
  c2->SetState("old");
  c1->Aciton();//A调用中介者通信方法与B通信
  c2->Aciton();
  cout<<endl;
  c1->SetState("new");
  c1->Aciton();
  c2->Aciton();
  cout<<endl;
  c2->SetState("old");
  c2->Aciton();
  c1->Aciton();

  delete m;
  delete c1;
  delete c2;
  system("pause");

  return 0;
}