中介者模式（Mediator）定义一个对象封装一系列多个对象如何相互作用，使得对象间不需要显式地相互引用，从而使其耦合更加松散，并且还让我们可以独立变化多个对象相互作用。结构图如下：
以一个聊天室的例子进行说明，一个聊天室可以很多成员，成员可以加入不同的讨论组，聊天室就是一个中介，讨论组中的成员通过聊天室发送消息。结构图如下：
实现代码：
//IChatroom.h
class User;
class IChatroom
{
public:
IChatroom();
virtual ~IChatroom();
virtual void Register(User*) = 0;
virtual void Send(char* pFrom, char* pTo, char* pMsg) = 0;
};
//IChatroom.cpp
#include "stdafx.h"
#include "IChatroom.h"
IChatroom::IChatroom()
{
}
IChatroom::~IChatroom()
{
}
//Chatroom.h
#include "IChatroom.h"
#include <map>
using namespace std;
class Chatroom : public IChatroom
{
public:
Chatroom();
virtual ~Chatroom();
void Register(User*);
void Send(char* pFrom, char* pTo, char* pMsg);
private:
map<char*, User*> m_mapUsers;
};
//Chatroom.cpp
#include "stdafx.h"
#include "Chatroom.h"
#include "User.h"
Chatroom::Chatroom()
{
}
Chatroom::~Chatroom()
{
}
void Chatroom::Register(User* pUser)
{
char* a = pUser->m_pName;
if(m_mapUsers[pUser->m_pName] == NULL)
{
m_mapUsers[pUser->m_pName] = pUser;
}
pUser->SetChatroom(this);
}
void Chatroom::Send(char* pFrom, char* pTo, char* pMsg)
{
User* pUserTo = (User*)m_mapUsers[pTo];
if(pUserTo != NULL)
{
pUserTo->Receive(pFrom, pMsg);
}
}
//User.h
class Chatroom;
class User
{
public:
User(char*);
virtual ~User();
void Send(char* pTo, char* pMsg);
virtual void Receive(char* pFrom, char* pMsg);
void SetChatroom(Chatroom*);
friend class Chatroom;
private:
char* m_pName;
Chatroom* m_pChatroom;
};
//User.cpp
#include "stdafx.h"
#include "User.h"
#include "Chatroom.h"
#include <iostream>
using namespace std;
User::User(char* pName)
{
m_pName = pName;
}
User::~User()
{
if(m_pChatroom != NULL)
{
delete m_pChatroom;
m_pChatroom = NULL;
}
}
void User::Send(char* pTo, char* pMsg)
{
m_pChatroom->Send(m_pName, pTo, pMsg);
}
void User::SetChatroom(Chatroom* pChatroom)
{
m_pChatroom = pChatroom;
}
void User::Receive(char* pFrom, char* pMsg)
{
cout << pFrom << " to " << this->m_pName << ":" << pMsg << endl;
}
//UserInGroupA.h
#include "User.h"
class UserInGroupA : public User
{
public:
UserInGroupA(char*);
virtual ~UserInGroupA();
virtual void Receive(char* pFrom, char* pMsg);
};
//UserInGroupA.cpp
#include "stdafx.h"
#include "UserInGroupA.h"
#include <iostream>
using namespace std;
UserInGroupA::UserInGroupA(char* pName) : User(pName)
{
}
UserInGroupA::~UserInGroupA()
{
}
void UserInGroupA::Receive(char* pFrom, char* pMsg)
{
cout << "组A成员收到消息-";
User::Receive(pFrom, pMsg);
}
//UserInGroupB.h
#include "User.h"
class UserInGroupB : public User
{
public:
UserInGroupB(char*);
virtual ~UserInGroupB();
virtual void Receive(char* pFrom, char* pMsg);
};
//UserInGroupB.cpp
#include "stdafx.h"
#include "UserInGroupB.h"
#include <iostream>
using namespace std;
UserInGroupB::UserInGroupB(char* pName) : User(pName)
{
}
UserInGroupB::~UserInGroupB()
{
}
void UserInGroupB::Receive(char* pFrom, char* pMsg)
{
cout << "组B成员收到消息-";
User::Receive(pFrom, pMsg);
}
//main.cpp
#include "stdafx.h"
#include "Chatroom.h"
#include "UserInGroupA.h"
#include "UserInGroupB.h"
int main(int argc, char* argv[])
{
Chatroom* pChatroom = new Chatroom;
User* pUserA = new UserInGroupA("UserA");
User* pUserB = new UserInGroupA("UserB");
User* pUserC = new UserInGroupB("UserC");
pChatroom->Register(pUserA);
pChatroom->Register(pUserB);
pChatroom->Register(pUserC);
pUserA->Send("UserB", "你好，UserB");
pUserB->Send("UserC", "你好，UserC");
pUserC->Send("UserA", "你好，UserA");
return 0;
}
最后输出：
组A成员收到消息-UserA to UserB:你好，UserB
组B成员收到消息-UserB to UserC:你好，UserC
组A成员收到消息-UserC to UserA:你好，UserA