设计模式-行为-中介者

#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;
}