State 模式

State模式中我们将状态逻辑和动作实现进行分离。允许一个对象在其内部状态改变时改变它的行为，对象看起来似乎修改了它的类；在一个状态即将结束的时候启用下一个状态。

 /////////state.h/////////////////////////////////////////////////////////////////
 #pragma  once
 class Context ;
 class State
 {
 public:
     virtual ~State();
     State();
     virtual void OperationInterface(Context* ) =  ;
     virtual void OperationChangeState(Context* ) =  ;

 protected:
     bool ChangeState(Context* con , State* st);
 private:
 };

 class  ConcreteStateA : public State
 {
 public:
     ~ConcreteStateA();
     ConcreteStateA();
     void OperationInterface(Context* );
     void OperationChangeState(Context* );
 protected:
 private:
 };

 class ConcreteStateB : public State
 {
 public:
     ~ConcreteStateB();
     ConcreteStateB();
     void OperationInterface(Context* );
     void OperationChangeState(Context* );
 protected:
 private:
 };

 ////////state.cpp//////////////////////////////////////////////////////////////////
 #include "state.h"
 #include "Context.h"
 #include <iostream>
 using namespace std;
 State::~State()
 {

 }
 State::State()
 {

 }
 bool State::ChangeState(Context* con , State* st)
 {
     con->ChangeState(st);
     return true ;
 }

 ConcreteStateA::ConcreteStateA()
 {

 }
 ConcreteStateA::~ConcreteStateA()
 {

 }
 void ConcreteStateA::OperationInterface(Context* con)
 {
     cout<<"ConcreteStateA::OperationInterface......"<<endl;
 }

 void ConcreteStateA::OperationChangeState(Context* con)
 {
     OperationInterface(con);
     this->ChangeState(con , new ConcreteStateB());
 }

 ConcreteStateB::~ConcreteStateB()
 {

 }
 ConcreteStateB::ConcreteStateB()
 {

 }
 void ConcreteStateB::OperationInterface(Context* con)
 {
     cout<<"ConcreteStateB::OperationInterface......"<<endl;
 }

 void ConcreteStateB::OperationChangeState(Context* con)
 {
     OperationInterface(con);
     this->ChangeState(con , new ConcreteStateA() );
 }

 //////////////////Context.h////////////////////////////////////////////////////////
 #pragma once
 class State;
 class Context
 {
 public:
     ~Context();
     Context();
     Context(State* st);
     void OprationInterface();
     void OperationChangState();
 protected:
 private:
     friend class State ;
     bool ChangeState(State* st);
     State* _st ;
 };

 /////////Context.cpp/////////////////////////////////////////////////////////////////
 #include "Context.h"
 #include "state.h"
 Context::Context()
 {

 }
 Context::Context(State* st)
 {
     _st = st ;
 }

 bool Context::ChangeState(State* st)
 {
     _st = st ;
     return true ;
 }
 Context::~Context()
 {
     delete _st ;
 }

 void Context::OprationInterface()
 {
     _st->OperationChangeState(this) ;//主要此处，调用时改变为下一个状态。
 }

 void Context::OperationChangState()
 {
     _st->OperationChangeState(this);
 }

 ////////main.cpp//////////////////////////////////////////////////////////////////
 #include "Context.h"
 #include "state.h"
 #include <iostream>
 using namespace std;
 int main()
 {
     State* st = new ConcreteStateA();
     Context* con = new Context(st);
     con->OprationInterface();
     con->OprationInterface();
     con->OprationInterface();
     if (con)
     {
         delete con ;
     }
     if (st)
     {
         delete st ;
     }
     getchar();
     return  ;
 }

State 模式在实现中，有两个关键点：
1）将 State 声明为 Context 的友元类（friend class） ，其作用是让 State 模式访问 Context 的 protected接口 ChangeSate（） 。

2）State 及其子类中的操作都将 Context*传入作为参数，其主要目的是 State 类可以通过这个指针调用 Context中的方法 （在本示例代码中没有体现）。这也是 State 模式和 Strategy 模式的最大区别所在。