设计模式之---调停者模式

调停者(中介者)模式（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

 

原文地址: http://www.cppblog.com/emptysoul/archive/2009/02/15/73892.html