常用设计模式总结三 -------中介者模式，状态模式，外观模式

7.中介者模式

简单的来说，就是为对象的交互提供一个中间的平台，使交互更加有序，对象也能更加简单。

 

首先我们看一个通用的中介模式钟的两个基类，

class Colleague
{
public:
     Colleague(Mediator *pMediator) : m_pMediator(pMediator){}

     virtual void Send(wchar_t *message) = 0;

protected:
     Mediator *m_pMediator;
};

class Mediator
{
public:
     virtual void Send(wchar_t *message, Colleague *pColleague) = 0;
};

再来看两个子类，可以看到中介子类ConcreteMediator中包含了两个成员变量分别为Colleague的子类。

class ConcreteColleague1 : public Colleague
{
public:
     ConcreteColleague1(Mediator *pMediator) : Colleague(pMediator){}

     void Send(wchar_t *message);

     void Notify(wchar_t *message)
     {
          wcout<<message<<endl;
     }
};

class ConcreteColleague2 : public Colleague
{
public:
     ConcreteColleague2(Mediator *pMediator) : Colleague(pMediator){}

     void Send(wchar_t *message);

     void Notify(wchar_t *message)
     {
          cout<<"ConcreteColleague2 is handling the message."<<endl;
          wcout<<message<<endl;
     }
};

 

class ConcreteMediator : public Mediator
{
public:
     // The mediator forward the message
     void Send(wchar_t *message, Colleague *pColleague)
     {
          ConcreteColleague1 *pConcreteColleague1 = dynamic_cast<ConcreteColleague1 *>(pColleague);
          if (pConcreteColleague1)
          {
               cout<<"The message is from ConcreteColleague1. Now mediator forward it to ConcreteColleague2"<<endl;
               if (m_pColleague2)
               {
                    m_pColleague2->Notify(message);
               }
          }
          else
          {
               if (m_pColleague1)
               {
                    m_pColleague1->Notify(message);
               }
          }
     }

     void SetColleague1(Colleague *pColleague)
     {
          m_pColleague1 = dynamic_cast<ConcreteColleague1 *>(pColleague);
     }

     void SetColleague2(Colleague *pColleague)
     {
          m_pColleague2 = dynamic_cast<ConcreteColleague2 *>(pColleague);
     }

private:
     // The Mediator knows all the Colleague
     ConcreteColleague1 *m_pColleague1;
     ConcreteColleague2 *m_pColleague2;
};

再看下 Colleague 子类的send函数，可以看到最后的执行其实是交给了Mediator

void ConcreteColleague1::Send(wchar_t *message)
{
     // The second parameter mark where the message comes from
     m_pMediator->Send(message, this);
}

void ConcreteColleague2::Send(wchar_t *message)
{
     m_pMediator->Sentd(message, this);
}

目的：1. 解决对象间交互较多的情况

           2. 解决一个类的对象需要与多个其他对象通信，导致该类难以复用

           3. 集中控制，但可能会导致一个类非常大

 

=============》

 

8.状态模式

简单说，消除条件分支，即当逻辑控制代码太复杂时候，考虑用不同状态的一系列类来表示。

​

class User
{
private:
    State* state;
public:
    User(State* state):state(state){}
    void Request();
    void ChangeState(State* state);
};

​

void User::Request()
{
    state->handle(this);
}

此时可以把状态的转化写在状态类的实现中。

void StateA::handle(User* pUser)
{
    std::cout << "StateA" << std::endl;
    pUser->ChangeState(new StateB());
}

比较简单，就不做过多的介绍

9.外观模式

简单的说，就是将各种模块组装成一个任务，减少其他开发人员的开发难度

class Work
{
private:
	Sub_Work1 w1;
	Sub_Work2 w2;
	Sub_Work3 w3;
	Sub_Work4 w4;
public:
	void Work1()//总工作1
	{
		w1.Working1();
		w3.Working3();
	}
	void Work2()//总工作2
	{
		w2.Working2();
		w3.Working3();
		w4.Working4();
	}
};