C++ 设计模式 - 【中介者模式】

#include <string>
#include <iostream>
#include <map>
#include <vector>


class Module;

/**
 * @class Mediator
 * @brief 中介者基类
 **/
class Mediator
{
public:
    virtual void toMediator(std::string msg, Module * p) = 0;
};

/**
 * @class Module
 * @brief 模块基类声明
 **/
class Module
{
protected:
    /// 中介者的引用
    Mediator * m_mediator;

public:

    /**
     * @brief 构造函数，new时传入中介者的引用
     * @param p[in] 中介者的引用
     **/
    Module(Mediator * p)
    {
        m_mediator = p;
    }

    /**
     * @brief 数据流向：模块-->中介者。纯虚函数，需要子类去定义功能
     * @param  msg[in] 
     **/
    virtual void toMediator(std::string msg) = 0;

    /**
     * @brief 数据流向：中介者-->模块。纯虚函数，需要子类去定义功能
     * @param  msg[in] 
     **/    
    virtual void toModule(std::string msg) = 0;
};

/**
 * @class ConcreteModule_0
 * @brief 具体模块0
 **/
class ConcreteModule_0 : public Module
{
public:
    /**
     * @brief 构造函数，new时传入中介者的引用
     * @param  p[in] 中介者的引用
     **/
    ConcreteModule_0(Mediator * p) : Module(p) {}

    void toMediator(std::string msg)
    {
        m_mediator->toMediator(msg, this);
    }
    void toModule(std::string msg)
    {
        std::cout << "Module_0 收到了消息：" << msg << std::endl;
        std::cout << "Module_0回应：没呢，你呢？" << std::endl;
    }
};

/**
 * @class ConcreteModule_1
 * @brief 具体模块1
 **/
class ConcreteModule_1 : public Module
{
public:
    /**
     * @brief 构造函数，new时传入中介者的引用
     * @param  p[in] 中介者的引用
     **/
    ConcreteModule_1(Mediator * p) : Module(p) {}

    void toMediator(std::string msg)
    {
        m_mediator->toMediator(msg, this);
    }
    void toModule(std::string msg)
    {
        std::cout << "Module_1 收到了消息：" << msg << std::endl;
        std::cout << "Module_1回应：没呢，你呢？" << std::endl;
    }
};

/**
 * @class ConcreteMediator
 * @brief 具体中介者
 **/
class ConcreteMediator : public Mediator
{
private:
    std::map<Module *, Module *> m_p;

public:
    void addModule(Module * p)
    {
        m_p[p] = p;
    }
    void toMediator(std::string msg, Module * p)
    {
        if ( 0 == m_p.count( p ) )
        {
            std::cout << "该模块未注册" << std::endl;
            return;
        }

        std::cout << "中介者得到消息：" << msg << std::endl;

        m_p[p]->toModule(msg);
    }
};

int main()
{
    // 中介者模式
    ConcreteMediator * p = new ConcreteMediator();
    std::vector<Module *> pListCol;
    pListCol.push_back( new ConcreteModule_0(p) );
    pListCol.push_back( new ConcreteModule_1(p) );

    for ( size_t i=0; i < pListCol.size(); i++ )
    {
        p->addModule( pListCol[i] );

        pListCol[i]->toMediator("你下班了吗？");

        delete pListCol[i];
    }

    delete p;

    return 0;
}