在C++面向对象开发中，当多个对象需要相互通信时，如果采用直接引用的方式交互，对象之间会形成复杂的网状依赖关系，修改其中一个对象的交互逻辑可能牵扯多个关联对象，大幅提升代码维护难度。中介者模式正是解决这类问题的经典设计模式，它通过引入一个中介者对象，将所有对象的交互逻辑集中到中介者中，对象之间不再直接通信，而是通过中介者转发请求，从而实现对象间的解耦，同时完成交互逻辑的集中控制。
中介者模式的核心结构
中介者模式包含四个核心角色，各角色的职责清晰划分，共同实现解耦和集中控制的目标：
- 抽象中介者（Mediator）：定义对象之间交互的统一接口，声明处理对象请求的方法。
- 具体中介者（ConcreteMediator）：实现抽象中介者的接口，持有所有参与交互的对象的引用，负责协调各对象之间的交互逻辑，是交互控制的中心。
- 抽象同事类（Colleague）：定义参与交互的对象的公共接口，持有中介者的引用，通过中介者与其他对象通信。
- 具体同事类（ConcreteColleague）：实现抽象同事类的接口，当需要与其他对象交互时，不直接调用其他同事的方法，而是向中介者发送请求。
C++实现示例：聊天室场景
以多用户聊天室场景为例，多个用户之间需要发送消息，如果没有中介者，每个用户都需要持有其他所有用户的引用才能发送消息，耦合度极高。使用中介者模式，聊天室作为中介者，用户只需要知道聊天室即可，消息由聊天室转发给所有其他用户。
1. 定义抽象中介者
#include <string>
#include <vector>
#include <iostream>
// 前置声明具体同事类
class ChatUser;
// 抽象中介者：聊天室接口
class ChatMediator {
public:
virtual ~ChatMediator() = default;
// 用户加入聊天室
virtual void addUser(ChatUser* user) = 0;
// 转发消息，发送者sender发送message给所有其他用户
virtual void sendMessage(ChatUser* sender, const std::string& message) = 0;
};
2. 定义抽象同事类
// 抽象同事类：聊天用户接口
class ChatUser {
protected:
ChatMediator* mediator; // 持有中介者引用
std::string name;
public:
ChatUser(ChatMediator* med, const std::string& userName)
: mediator(med), name(userName) {}
virtual ~ChatUser() = default;
// 发送消息，调用中介者的转发方法
virtual void send(const std::string& message) = 0;
// 接收消息
virtual void receive(ChatUser* sender, const std::string& message) = 0;
std::string getName() const { return name; }
};
3. 实现具体中介者和具体同事类
// 具体中介者：普通聊天室
class SimpleChatRoom : public ChatMediator {
private:
std::vector<ChatUser*> users; // 持有所有用户的引用
public:
void addUser(ChatUser* user) override {
users.push_back(user);
}
void sendMessage(ChatUser* sender, const std::string& message) override {
// 遍历所有用户，除了发送者本身，都转发消息
for (ChatUser* user : users) {
if (user != sender) {
user->receive(sender, message);
}
}
}
};
// 具体同事类：普通聊天用户
class NormalChatUser : public ChatUser {
public:
NormalChatUser(ChatMediator* med, const std::string& userName)
: ChatUser(med, userName) {
// 用户创建后自动加入聊天室
med->addUser(this);
}
void send(const std::string& message) override {
std::cout << name << " 发送消息: " << message << std::endl;
// 调用中介者转发消息，不直接调用其他用户的方法
mediator->sendMessage(this, message);
}
void receive(ChatUser* sender, const std::string& message) override {
std::cout << name << " 收到 " << sender->getName() << " 的消息: " << message << std::endl;
}
};
4. 客户端使用示例
int main() {
// 创建中介者：聊天室
SimpleChatRoom chatRoom;
// 创建用户，用户会自动加入聊天室
NormalChatUser user1(&chatRoom, "张三");
NormalChatUser user2(&chatRoom, "李四");
NormalChatUser user3(&chatRoom, "王五");
// 用户发送消息，消息由聊天室转发
user1.send("大家好，我是张三");
std::cout << "------------------------" << std::endl;
user2.send("你好张三，我是李四");
return 0;
}
上述代码的输出结果如下：
张三 发送消息: 大家好，我是张三 李四 收到 张三 的消息: 大家好，我是张三 王五 收到 张三 的消息: 大家好，我是张三 ------------------------ 李四 发送消息: 你好张三，我是李四 张三 收到 李四 的消息: 你好张三，我是李四 王五 收到 李四 的消息: 你好张三，我是李四
解耦与集中控制的实现原理
从上面的示例可以看出，中介者模式通过两个核心设计实现解耦和集中控制：
- 解耦实现：所有
ChatUser对象不再持有其他ChatUser的引用，仅依赖ChatMediator接口，对象之间的依赖从网状变成了星型，修改某个用户的交互逻辑不会影响其他用户，只需要调整中介者的转发逻辑即可。 - 集中控制实现：所有对象的交互逻辑都封装在
SimpleChatRoom的sendMessage方法中，如果需要新增消息过滤、消息记录等功能，只需要在中介者中修改代码，不需要改动所有同事类。
适用场景与优缺点
适用场景
- 系统中多个对象之间存在复杂的网状交互关系，维护困难。
- 希望将多个对象的交互逻辑集中管理，避免逻辑分散在各个对象中。
- 需要降低对象之间的耦合度，方便单独修改或替换某个交互对象。
优点
- 显著降低对象之间的耦合度，减少类的依赖关系。
- 交互逻辑集中管理，符合单一职责原则，便于维护和扩展。
- 新增同事类时，只需要修改中介者的逻辑，不需要修改现有同事类。
缺点
- 中介者会成为系统的中心，所有交互逻辑都集中在中介者中，可能导致中介者类过于庞大复杂，反而难以维护。
- 如果中介者的接口设计不合理，新增交互场景时可能需要修改抽象中介者接口，影响所有实现类。
总结
中介者模式通过引入中心化的中介者对象，将对象之间的直接交互转换为对象与中介者的交互，有效解决了多对象复杂交互带来的高耦合问题，同时实现了交互逻辑的集中控制。在C++中实现该模式时，需要注意合理划分抽象中介者和具体中介者的职责，避免中介者类过度膨胀。实际开发中，需要根据对象交互的复杂程度判断是否使用该模式，避免过度设计。