一、应用

如果一个系统中对象之间的联系呈现出网状结构，对象之间存在大量多对多关系，将导致关系极其复杂，这些对象称为 "同事对象"。我们可以引入一个中介者对象，使各个同事对象只跟中介者对象打交道，将同事对象之间的关系行为进行分离和封装，使之成为一个松耦合的系统。

解耦各个同事对象之间的交互关系。每个对象都持有中介者对象的引用，只跟中介者对象打交道。通过中介者对象统一管理这些交互关系，并且还可以在同事对象的逻辑上封装自己的逻辑。

二、代码

class Mediator {
public:
    virtual ~Mediator() = default;

    virtual void Notify(string event) const = 0;
};

class BaseComponent {
protected:
    Mediator *mediator;
public:
    void SetMediator(Mediator *mediator1) {
        this->mediator = mediator1;
    }
    BaseComponent(Mediator *mediator1 = nullptr) : mediator(mediator1) {}
    ~BaseComponent() = default;
};

// 组件一
class Component1 : public BaseComponent {
public:
    void UseComponent2() {
        this->mediator->Notify("UseComponent2");
    }
};

// 组件二
class Component2 : public BaseComponent {
public:
    void Process() {
        cout << "Process Component2" << endl;
    }
};

// 避免多个组件直接交互，使用中介者进行交互
class ConcreteMediator : public Mediator {
private:
    Component1 *component1;
    Component2 *component2;
public:
    ConcreteMediator(Component1 *component1, Component2 *component2) : component1(component1), component2(component2) {
        this->component1->SetMediator(this);
        this->component2->SetMediator(this);
    }

    // 调用其他同事对象
    void Notify(string event) const override {
        if (event == "UseComponent2") {
            this->component2->Process();
        }
    }
};

int main() {
    Component1 *component1 = new Component1;
    Component2 *component2 = new Component2;
    ConcreteMediator *concreteMediator = new ConcreteMediator(component1, component2);
    // component1通过中介去调用Component2
    component1->UseComponent2();

    delete component1;
    delete component2;
    delete concreteMediator;
}

三、参考

www.zhihu.com/question/48… blog.csdn.net/u012011079/…