1、在面向对象系统设计和开发的过程中，对象之间的交互和通信是最为常见的情况，系统比较小的时候，可能对象间的通信不是很多，对象也比较少，我们可以直接硬编码到各个对象的方法中，但是当系统规模变大，对象的种类数量增多，对象量变引起系统复杂度急剧增加，对象间的通信也变得复杂，这时我们需要提供一个专门处理对象间交互和通信的类。这就是中介者模式。用一个中介对象来封装对象一系列的交互和通信，使各个对象不需要显式的互相引用，从而使其耦合松散，而且可以独立的改变它们之间的交互，大大降低了系统的复杂性，中介者模式的例子有很多，大到联合国安理会，小到房屋中介，都扮演了中介者的角色，协调各方利益。
2、我们以租房子为例，如果没有房屋中介，那么房客要自己找房东，而房东也要自己找访客，非常的不方便，有了房屋中介机构，房东可以把要出租的房屋信息放到中介机构，而房客可以去中介机构咨询。在软件中，就是多个对象之间需要通信，如果没有中介，对象就需要知道其他对象，最坏情况下可能需要知道所有其他对象，而有了中介对象就方便多了，对象只需与中介对象通信，而不用知道其他对象。
#include<iostream>
#include<string>
#include<list>
using namespace std;
class Mediator;
//抽象人
class Person
{
public:
string m_name;
protected:
Mediator *m_mediator; //中介
public:
virtual void SetMediator(Mediator* mediator){
} //设置中介
virtual void SendMessage(string message){
} //向中介发送信息（然后中介帮我发出去）
virtual void GetMessage(string message){
} //从中介中获取信息（中介告诉我别人发来的消息）
};
//抽象中介机构
class Mediator{
protected:
list<Person*> m_listrenter; //租房者集合
list<Person*> m_listlandlord; //房东集合
public:
void push_renter(Person* A)
{
m_listrenter.push_back(A);
}
void push_landlord(Person* B)
{
m_listlandlord.push_back(B);
}
virtual void Send(string message, Person *person){
};
virtual void SetRenter(Person* A){
} //中介机构需要知道来的是租客还是房东
virtual void SetLandlord(Person* B){
}
};
//租房者
class Renter:public Person
{
public:
Renter(string name)
{
m_name = name;
}
public:
void SetMediator(Mediator* mediator)
{
m_mediator = mediator;
}
void SendMessage(string message) //send给landlord 通过中介者 不仅要传给中介者所发的消息，还要告诉他我是租客还是房东
{
m_mediator->Send(message,this);
}
void GetMessage(string message)
{
cout<<m_name<<"租房者收到信息:"<<message<<endl;
}
};
//房东
class Landlord:public Person
{
public:
Landlord(string name)
{
m_name = name;
}
public:
void SetMediator(Mediator* mediator)
{
m_mediator = mediator;
}
void SendMessage(string message) //send给renter 通过中介者 不仅要传给中介者消息，还要告诉他我是房东还是租房者
{
m_mediator->Send(message,this);
}
void GetMessage(string message)
{
cout<<m_name<<"房东收到信息:"<<message<<endl;
}
};
//房屋中介
class HouseMediator : public Mediator
{
private:
Person *m_renter; //租房者
Person *m_landlord; //房东
public:
HouseMediator(): m_renter(0), m_landlord(0) {
}
void SetRenter(Person *A) //设置现在想要发消息的是租房者还是房东
{
m_renter = A;
}
void SetLandlord(Person *B)
{
m_landlord = B;
}
void Send(string message, Person *person)
{
if(person == m_renter){
list<Person*> ::iterator ite = m_listlandlord.begin();
while(ite != m_listlandlord.end())
{
(*ite)->GetMessage(message);
ite++;
}
}
else
{
list<Person*> ::iterator ite = m_listrenter.begin();
while(ite != m_listrenter.end())
{
(*ite)->GetMessage(message);
ite++;
}
}
}
};
int main()
{
Mediator* mediator = new HouseMediator();
Person* renter1 = new Renter("租客1");
Person* renter2 = new Renter("租客2");
Person* landlord1 = new Landlord("房东1");
mediator->push_renter(renter1);
mediator->push_renter(renter2);
mediator->push_landlord(landlord1);
renter1->SetMediator(mediator); //相当于租客或者房东和这家中介机构绑定了
renter2->SetMediator(mediator);
landlord1->SetMediator(mediator);
mediator->SetRenter(renter1);//告诉中介我是房东还是租客
renter1->SendMessage("我想要租一个学区房，联系方式111111"); //租客发消息 走到函数里（去函数里看一眼！） 就是租客上面绑定的中介替他把消息发送到房东手中
mediator->SetRenter(renter2);
renter2->SendMessage("我想要租一个带阳台的房子，联系方式222222");
mediator->SetLandlord(landlord1);
landlord1->SendMessage("出租学区房，联系方式333333");
delete renter1; delete renter2;delete landlord1;delete mediator;
return 0;
}
细心的朋友应该发现了上面的代码里面还有观察者模式的影子，每个租房者和房东既是观察者，也是被观察者，当一个人来到了中介机构，他需要和中介表明自己的身份，比如他是房东（被观察者），那么中介就会帮他把他想要出租的房子的信息发送到每一个租房者（观察者）手里。租房者来到中介也是如此。
3、中介者模式是一种很有用并且很常用的模式，它通过将对象间的通信封装到一个类中，将多对多的通信转化为一对多的通信，降低了系统的复杂性。中介者模式还有一个很显著的特点就是将控制集中，集中的优点就是便于管理，也正式符合了 OO 设计中的每个类的职责要单一和集中的原则。（PS：OO设计原则，即面向对象的设计原则，OO(Object Oriented,面向对象) ）
部分内容参考于：https://blog.csdn.net/wuzhekai1985/article/details/6673603