中介者模式（mediator）（C++）

什么是中介者模式

**中介者模式mediator，**用一个中介对象来封装一系列的对象交互，中介者对象使各对象不需要显示的相互引用，从而使其耦合松散，并且可以独立的改变他们之间的交互方式

角色

角色	角色作用
抽象中介者	包含一个所有col对象，和一个抽象接口
具体中介者	实现具体接口
抽象同事	包含中介，以及与中介交互的接口
具体同事	实现接口

#include <string>
#include <iostream>
#include<vector>
#include<initializer_list>
using namespace std;
class Colleague; \\必须前项申明，不然编译不过

class Mediator \\抽象中介者
{
public:
    virtual void send(std::string  msg, Colleague * p, string receiveName) = 0; \\send函数，用于col之间消息交互，包含消息msg，发送方p，和接收方name
};

class Colleague \\col抽象类
{
protected:
    Mediator * m_mediator; \\每个对象都应该认识中介
    string selfName; \\每个对象名字
public:
    Colleague(Mediator * p, string name)
    {
        m_mediator = p;
        selfName = name;
    }
    virtual void send(std::string msg, string receiveName) = 0;
    virtual void notify(std::string msg, string sendName) = 0;
    const string getSelfName()
    {
        return selfName;
    }
};

class ConcreteColleague : public Colleague
{
public:
    ConcreteColleague(Mediator * p, string name) : Colleague(p, name) {}
    void send(std::string msg, string receiveName)
    {
        m_mediator->send(msg, this, receiveName);
    }
    void notify(std::string msg, string sendName)
    {
        std::cout << sendName << "send" << msg << "to" << this->getSelfName() << std::endl;
    }
};


class ConcreteMediator : public Mediator
{
private:
    vector<Colleague *> collList;
public:
    void addColleague(initializer_list<Colleague *> initList)
    {
        for(auto it : initList)
            collList.push_back(it);
    }
    void send(std::string msg, Colleague * p, string receiveName)
    {
        // 这里接受来自一个同事发过来的消息，具体应该给谁要根据需求来
        // 这里知识一个很简单的应用。比如该类总可以是有两个队列。
        // 一个队列是客户，一个队列是客服
        for(auto it : collList)
        {
            if(receiveName == it->getSelfName())
            {
                it->notify(msg, p->getSelfName());
            }
        }
    }
};

int main()
{
    // 中介者模式
    ConcreteMediator * p = new ConcreteMediator();
    Colleague * pCol1 = new ConcreteColleague(p, "col1");
    Colleague * pCol2 = new ConcreteColleague(p, "col2");
    p->addColleague({pCol1, pCol2});
    pCol1->send("你下班了吗？", "col2");

    delete pCol1;
    delete pCol2;
    delete p;

    getchar();
    return 0;
}

这里我改变了很多实现，都是自己添加的
https://blog.csdn.net/konglongdanfo1/article/details/83381630
与该博客中实现有差别，但是具体的意义是一样的

应用场景

①优点

减少类间依赖，把一对多的依赖转变成一对一。同事类只依赖中介，降低类间耦合

②缺点，中介者会随着同事类的增多，逻辑越来越复杂