【c++设计模式之中介者模式】分析及示例

中介者模式属于行为型设计模式，旨在减少对象之间的耦合关系，通过引入一个中介者对象，将对象间复杂的交互转化为中介者与对象之间的简单交互，中介者模式实现了集中式控制，有助于系统的维护和扩展。

以下是一个使用中介者模式的示例，假设有多个同事对象（Colleague），这些同事对象以不同方式交互，为了解耦合，引入一个中介者对象（Mediator），该中介者对象负责协调所有同事对象之间的交互，如下所示：

在上图中，Colleague类是抽象同事类，具体同事类ConcreteColleague1和ConcreteColleague2继承自该类。Mediator是抽象中介者类，具体中介者类ConcreteMediator继承自该类并实现中介者的具体逻辑。

具体代码实现如下：

//抽象同事类
class Colleague
{
public:
    Colleague(Mediator* mediator) : m_mediator(mediator) {}
    virtual void sendMsg(std::string msg) = 0;
    virtual void receiveMsg(std::string msg) = 0;
protected:
    Mediator* m_mediator;
};

//具体同事类1
class ConcreteColleague1 : public Colleague
{
public:
    ConcreteColleague1(Mediator* mediator) : Colleague(mediator) {}
    void sendMsg(std::string msg) override
    {
        m_mediator->sendMsg(msg, this);
    }
    void receiveMsg(std::string msg) override
    {
        std::cout << "ConcreteColleague1 received msg: " << msg << std::endl;
    }
};

//具体同事类2
class ConcreteColleague2 : public Colleague
{
public:
    ConcreteColleague2(Mediator* mediator) : Colleague(mediator) {}
    void sendMsg(std::string msg) override
    {
        m_mediator->sendMsg(msg, this);
    }
    void receiveMsg(std::string msg) override
    {
        std::cout << "ConcreteColleague2 received msg: " << msg << std::endl;
    }
};

//抽象中介者类
class Mediator
{
public:
    virtual void sendMsg(std::string msg, Colleague* sender) = 0;
};

//具体中介者类
class ConcreteMediator : public Mediator
{
public:
    ConcreteMediator() {}
    void sendMsg(std::string msg, Colleague* sender) override
    {
        auto iter = m_colleagues.find(sender);
        if (iter != m_colleagues.end())
        {
            for (auto it = m_colleagues.begin(); it != m_colleagues.end(); ++it)
            {
                if (it->first != iter->first)
                {
                    it->second->receiveMsg(msg);
                }
            }
        }
    }
    void addColleague(Colleague* colleague)
    {
        m_colleagues[colleague] = colleague;
    }
private:
    std::map<Colleague*, Colleague*> m_colleagues;
};

int main()
{
    ConcreteMediator mediator;
    ConcreteColleague1 colleague1(&mediator);
    ConcreteColleague2 colleague2(&mediator);
    mediator.addColleague(&colleague1);
    mediator.addColleague(&colleague2);
    colleague1.sendMsg("Hello, this is ConcreteColleague1.");
    colleague2.sendMsg("Hi, this is ConcreteColleague2.");

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

在上述代码中，Colleague类是抽象同事类，ConcreteColleague1和ConcreteColleague2是具体同事类，它们都继承自Colleague类，并实现了虚函数sendMsg和receiveMsg。Mediator是抽象中介者类，ConcreteMediator是具体中介者类，它们都继承自Mediator类，并实现了虚函数sendMsg。

在main函数中，创建了具体中介者ConcreteMediator对象以及两个具体同事ConcreteColleague1和ConcreteColleague2对象，并将它们加入ConcreteMediator对象的同事列表中。接着分别调用ConcreteColleague1对象和ConcreteColleague2对象的sendMsg函数，向ConcreteMediator对象发送消息，最终得到正确的输出结果。

总之，中介者模式通过引入中介者对象，将对象间复杂的交互转化为中介者与对象之间的简单交互，从而减少了对象之间的耦合关系。在实际应用中，开发人员可以根据实际需要灵活使用中介者模式，以获得更好的系统拓展性和可维护性。