中介者模式（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