设计模式-行为-Mediator（中介者）模式

对象之间的交互是一种非常普遍的需求。当系统规模较大、对象数量众多时，相互通信的复杂度会急剧上升。为了管理这种复杂性，需要引入一个专门负责协调交互的通信类，这正是 Mediator（中介者）模式的核心思想，它同时也带来了系统间对象的松耦合。

Mediator 模式的价值在于：它将对象间的通信封装到一个独立的类中，把原本的多对多通信关系转换为一对多，从而显著降低了通信的复杂性。借助 Mediator，各个 Colleague 无需直接维护彼此的通信对象和协议，系统耦合度大幅下降，Mediator 与 Colleague 也可以相互独立地演进和修改。

此外，Mediator 模式还具备集中控制的特点，便于统一管理，也符合面向对象设计中每个类单一职责的原则。

示例代码

头文件
                #pragma  once
                #include "PublicHeaders.h"
                
                class Mediator;
                
                
                class Colleague
                {
                public:
                	virtual void Action() = 0;
                
                protected:
                	Mediator *_mediator;
                	friend class ConCreateMediator;
                	virtual void Sync() = 0;
                
                };
                
                class ConCreateColleagueA :public Colleague
                {
                public:
                	ConCreateColleagueA(Mediator*m);
                	virtual void Action()override;
                private:
                
                	virtual void Sync()override;
                };
                
                class ConCreateColleagueB :public Colleague
                {
                public:
                	ConCreateColleagueB(Mediator*m);
                	virtual void Action()override;
                private:
                
                	virtual void Sync()override;
                };
                
                
                
                class Mediator
                {
                public:
                	virtual void IntroColleague(Colleague*a, Colleague *b) = 0;
                	virtual void DoActionFromAtoB() = 0;
                	virtual void DoActionFromBtoA() = 0;
                
                
                protected:
                	Colleague *colleague_A;
                	Colleague *colleague_B;
                
                
                };
                
                
                class ConCreateMediator :public Mediator
                {
                public:
                	virtual void IntroColleague(Colleague*a, Colleague *b)override;
                	virtual void DoActionFromAtoB()override;
                	virtual void DoActionFromBtoA()override;
                
                };
                
                
                
                void testMediator();
                
                
                
                
                源文件
                #include "Mediator.h"
                
                
                
                
                ConCreateColleagueA::ConCreateColleagueA(Mediator*m)
                {
                	this->_mediator = m;
                }
                void ConCreateColleagueA::Action()
                {
                	this->_mediator->DoActionFromAtoB();
                }
                
                
                void  ConCreateColleagueA::Sync()
                {
                	cout << __FUNCTION__ << endl;
                }
                
                
                ConCreateColleagueB::ConCreateColleagueB(Mediator*m)
                {
                	this->_mediator = m;
                }
                void  ConCreateColleagueB::Action()
                {
                	this->_mediator->DoActionFromBtoA();
                }
                
                void ConCreateColleagueB::Sync()
                {
                	cout << __FUNCTION__ << endl;
                }
                
                
                
                
                
                
                void  ConCreateMediator::IntroColleague(Colleague*a, Colleague *b)
                {
                	this->colleague_A = a;
                	this->colleague_B = b;
                }
                void ConCreateMediator::DoActionFromAtoB()
                {
                	colleague_B->Sync();
                }
                void  ConCreateMediator::DoActionFromBtoA()
                {
                	colleague_A->Sync();
                }
                
                
                
                
                void testMediator()
                {
                	ConCreateMediator* mediator = new ConCreateMediator;
                
                	ConCreateColleagueA *a = new ConCreateColleagueA(mediator);
                	ConCreateColleagueB *b = new ConCreateColleagueB(mediator);
                	mediator->IntroColleague(a, b);
                
                	a->Action();
                	b->Action();
                	a->Action();
                
                
                
                }