C++中介者模式

中介者模式

中介者模式是一种行为设计模式，它通过引入一个中介者对象来封装一组对象之间的交互。中介者模式可以降低对象之间的耦合度，使得对象之间的通信更加简单和灵活。

使用场景：

1、当一个系统中的对象之间存在复杂的交互关系，且这些交互关系难以维护时，可以考虑使用中介者模式。
2、当一个对象需要和多个其他对象进行通信，但是不希望直接依赖这些对象时，中介者模式也是一个不错的选择。

优势：

1、降低了对象之间的耦合度，使得系统更加灵活和易于扩展。
2、可以集中控制对象之间的交互，提高了系统的可维护性和可读性。

劣势：

1、中介者对象可能会变得过于复杂，难以维护。
2、中介者模式可能会导致系统变得更加复杂，增加了代码的复杂度。

Code

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

class Colleague;

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

class Colleague {
protected:
    Mediator* mediator;

public:
    Colleague(Mediator* mediator) : mediator(mediator) {}

    virtual void sendMessage(const std::string& message) = 0;
    virtual void receiveMessage(const std::string& message) = 0;
};

class ConcreteColleagueA : public Colleague {
public:
    ConcreteColleagueA(Mediator* mediator) : Colleague(mediator) {}

    void sendMessage(const std::string& message) override {
        mediator->sendMessage(this, message);
    }

    void receiveMessage(const std::string& message) override {
        std::cout << "Concrete Colleague A received message: " << message << std::endl;
    }
};

class ConcreteColleagueB : public Colleague {
public:
    ConcreteColleagueB(Mediator* mediator) : Colleague(mediator) {}

    void sendMessage(const std::string& message) override {
        mediator->sendMessage(this, message);
    }

    void receiveMessage(const std::string& message) override {
        std::cout << "Concrete Colleague B received message: " << message << std::endl;
    }
};

class ConcreteMediator : public Mediator {
private:
    std::vector<Colleague*> colleagues;

public:
    void addColleague(Colleague* colleague) {
        colleagues.push_back(colleague);
    }

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

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

    mediator.addColleague(&colleagueA);
    mediator.addColleague(&colleagueB);

    colleagueA.sendMessage("Hello from Colleague A");
    colleagueB.sendMessage("Hi from Colleague B");

    while (1);
    return 0;
}