C++中介者模式有什么优势 降低对象间耦合度的实现方式

Notify(Component* sender, const std::string& event)

IMediator

Notify

IMediator

Component

mediator_->Notify(this, "some_event")

#include <iostream>
#include <string>
#include <vector>
#include <memory> // For std::shared_ptr

// 前向声明
class IMediator;

// 抽象组件基类
class Component {
protected:
    IMediator* mediator_; // 知道中介者接口
public:
    explicit Component(IMediator* mediator = nullptr) : mediator_(mediator) {}
    void SetMediator(IMediator* mediator) {
        mediator_ = mediator;
    }
    virtual ~Component() = default;
};

// 抽象中介者接口
class IMediator {
public:
    virtual void Notify(Component* sender, const std::string& event) = 0;
    virtual ~IMediator() = default;
};

// 具体组件A
class ConcreteComponentA : public Component {
public:
    explicit ConcreteComponentA(IMediator* mediator = nullptr) : Component(mediator) {}
    void DoSomethingA() {
        std::cout << "ComponentA: Doing something and notifying mediator.\n";
        if (mediator_) {
            mediator_->Notify(this, "EventA_Done");
        }
    }
    void ReactToB() {
        std::cout << "ComponentA: Reacting to something ComponentB did.\n";
    }
};

// 具体组件B
class ConcreteComponentB : public Component {
public:
    explicit ConcreteComponentB(IMediator* mediator = nullptr) : Component(mediator) {}
    void DoSomethingB() {
        std::cout << "ComponentB: Doing something and notifying mediator.\n";
        if (mediator_) {
            mediator_->Notify(this, "EventB_Done");
        }
    }
    void ReactToA() {
        std::cout << "ComponentB: Reacting to something ComponentA did.\n";
    }
};

// 具体中介者
class ConcreteMediator : public IMediator {
private:
    ConcreteComponentA* componentA_;
    ConcreteComponentB* componentB_;
public:
    void SetComponents(ConcreteComponentA* a, ConcreteComponentB* b) {
        componentA_ = a;
        componentB_ = b;
        // 确保组件知道中介者
        if (componentA_) componentA_->SetMediator(this);
        if (componentB_) componentB_->SetMediator(this);
    }

    void Notify(Component* sender, const std::string& event) override {
        if (sender == componentA_ && event == "EventA_Done") {
            std::cout << "Mediator: ComponentA finished. Now asking ComponentB to react.\n";
            if (componentB_) {
                componentB_->ReactToA();
            }
        } else if (sender == componentB_ && event == "EventB_Done") {
            std::cout << "Mediator: ComponentB finished. Now asking ComponentA to react.\n";
            if (componentA_) {
                componentA_->ReactToB();
            }
        }
        // 可以有更复杂的逻辑
    }
};

/*
int main() {
    ConcreteMediator mediator;
    ConcreteComponentA componentA;
    ConcreteComponentB componentB;

    mediator.SetComponents(&componentA, &componentB);

    componentA.DoSomethingA();
    std::cout << "---\n";
    componentB.DoSomethingB();

    // 输出会是：
    // ComponentA: Doing something and notifying mediator.
    // Mediator: ComponentA finished. Now asking ComponentB to react.
    // ComponentB: Reacting to something ComponentA did.
    // ---
    // ComponentB: Doing something and notifying mediator.
    // Mediator: ComponentB finished. Now asking ComponentA to react.
    // ComponentA: Reacting to something ComponentB did.

    return 0;
}
*/

ConcreteComponentA

ConcreteComponentB

IMediator

ConcreteMediator