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

中介者模式在c++++中通过集中管理对象交互来降低耦合度。1. 它像交通指挥员一样协调对象通信，避免混乱；2. 高耦合如同齿轮咬合，修改一个类可能引发连锁问题，如电商系统中购物车与支付模块的依赖故障；3. 实现步骤包括定义mediator接口、colleague基类、具体同事类与中介者类，通过注册与转发机制实现解耦；4. 应用场景涵盖电商系统、聊天室、gui组件协调等；5. 优点是降低耦合、提升可维护性，缺点是中介者可能成为复杂度集中的“上帝对象”；6. 拆分职责或结合观察者模式可避免过度集中；7. 该模式适用于java、python等语言，核心思想一致，但实现方式因语言特性而异。

中介者模式在C++里，就像一个老练的交通指挥员，专门负责疏导各个路口的车辆，避免它们乱成一锅粥。它能有效减少对象间的直接依赖，让系统更加灵活，也更容易维护。想象一下，如果没有交通规则和指挥，城市交通会瘫痪成什么样？中介者模式的作用就是制定规则，并负责监督执行。

减少对象耦合，集中式事件调度系统设计

为什么C++里对象耦合是个大问题？

对象耦合度高，就像两个齿轮紧紧咬合在一起，一个齿轮稍微出点问题，另一个也得跟着遭殃。在C++里，这意味着修改一个类，可能导致整个项目都要重新编译甚至修改。这不仅浪费时间，还增加了引入bug的风险。想象一下，如果一个电商网站的购物车类和支付类紧密耦合，修改了购物车计算逻辑，结果支付系统也出错了，这可不是闹着玩的。中介者模式通过将对象间的交互行为集中到一个中介者对象中，从而降低了各个对象间的直接依赖，让它们可以更独立地进行修改和扩展。

立即学习“C++免费学习笔记（深入）”；

如何用C++实现一个简单的中介者模式？

咱们先定义一个Colleague基类，代表需要交互的对象：

Pic Copilot

AI时代的顶级电商设计师，轻松打造爆款产品图片

下载

#include 
#include 
#include 

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 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;
}

这个例子里，ConcreteMediator负责协调ConcreteColleagueA和ConcreteColleagueB之间的通信。 Colleague通过send方法发送消息，Mediator负责将消息转发给其他Colleague。

中介者模式在实际项目中的应用场景有哪些？

除了上面提到的电商系统，中介者模式在很多地方都能派上用场。比如，在一个多人聊天室里，聊天室本身就可以充当一个中介者，负责接收用户的消息，然后转发给其他用户。再比如，在一个复杂的GUI应用中，各个UI组件之间的交互也可以通过中介者来协调。

中介者模式的优缺点是什么？

优点很明显，降低了对象之间的耦合度，提高了系统的可维护性和可扩展性。但缺点也很突出，中介者本身可能会变得非常复杂，承担过多的责任，变成一个“上帝对象”。所以，在使用中介者模式时，需要仔细权衡，避免过度设计。

如何避免中介者变成“上帝对象”？

关键在于合理拆分中介者的职责。可以将一个大的中介者拆分成多个小的中介者，每个中介者负责一部分职责。或者，可以引入观察者模式，让中介者只负责协调对象之间的交互，而不负责具体的业务逻辑。

除了C++，中介者模式在其他语言中如何实现？

中介者模式是一种通用的设计模式，可以在各种面向对象编程语言中实现。比如，在Java中，可以使用接口来定义中介者和同事类，然后通过具体的类来实现这些接口。在Python中，由于其动态类型的特性，实现起来更加灵活。核心思想都是一样的，就是将对象间的交互行为集中到一个中介者对象中，从而降低对象间的耦合度。