C++中介者模式怎样减少对象耦合 集中式事件调度系统设计

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

class Mediator; // 前向声明

class Colleague {
public:
    Colleague(Mediator* mediator) : mediator_(mediator) {}
    virtual ~Colleague() {}

    virtual void receive(const std::string& message) = 0;
    void send(const std::string& message);

protected:
    Mediator* mediator_;
};

class Mediator {
public:
    virtual ~Mediator() {}
    virtual void registerColleague(Colleague* colleague) = 0;
    virtual void sendMessage(Colleague* sender, const std::string& message) = 0;
};

class ConcreteColleagueA : public Colleague {
public:
    ConcreteColleagueA(Mediator* mediator) : Colleague(mediator) {
        mediator_->registerColleague(this);
    }

    void receive(const std::string& message) override {
        std::cout << "ConcreteColleagueA received: " << message << std::endl;
    }
};

class ConcreteColleagueB : public Colleague {
public:
    ConcreteColleagueB(Mediator* mediator) : Colleague(mediator) {
        mediator_->registerColleague(this);
    }

    void receive(const std::string& message) override {
        std::cout << "ConcreteColleagueB received: " << message << std::endl;
    }
};

class ConcreteMediator : public Mediator {
public:
    void registerColleague(Colleague* colleague) override {
        colleagues_.push_back(colleague);
    }

    void sendMessage(Colleague* sender, const std::string& message) override {
        for (Colleague* colleague : colleagues_) {
            if (colleague != sender) {
                colleague->receive(message);
            }
        }
    }

private:
    std::vector<Colleague*> colleagues_;
};

void Colleague::send(const std::string& message) {
    mediator_->sendMessage(this, message);
}


int main() {
    ConcreteMediator mediator;
    ConcreteColleagueA colleagueA(&mediator);
    ConcreteColleagueB colleagueB(&mediator);

    colleagueA.send("Hello from A!");
    colleagueB.send("Hi from B!");

    return 0;
}