zoukankan      html  css  js  c++  java
  • 设计模式-中介者模式

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

  • 相关阅读:
    Linux 共享库
    使用Visual Studio(VS)开发Qt程序代码提示功能的实现(转)
    ZOJ 3469 Food Delivery(区间DP)
    POJ 2955 Brackets (区间DP)
    HDU 3555 Bomb(数位DP)
    HDU 2089 不要62(数位DP)
    UESTC 1307 windy数(数位DP)
    HDU 4352 XHXJ's LIS(数位DP)
    POJ 3252 Round Numbers(数位DP)
    HDU 2476 String painter (区间DP)
  • 原文地址:https://www.cnblogs.com/rosesmall/p/2418326.html
Copyright © 2011-2022 走看看