设计模式 ——状态模式

“状态变化”模式

在组件构建过程中，某些对象的状态经常面临变化，如何对这些变化进行有效的管理？同时又维持高层模块的稳定？“状态变化”模式应运而生。
典型模式 ：State、 Memento

State 状态模式

在实际开发中，经常会遇到，一个对象有多种状态，在每一个状态下，都有不同的行为。如下：

typedef enum tagState
{
     state0,
     state1,
     state2
}State;

//根据不同的state执行不同的DoSomrthing，就实际上相当于不同的Handle
void Handle(State state)
{
     if (state == state0){
          // DoSomethingA
     } else if (state == state1){
          // DoSomethingB
     } else if (state == state2){
          // DoSomethingC
     }else {
          // DoSomethingD
     }
}

//等效于根据不同的state调用不同的Handle
void Handle(state0) { //Do somethingA }
void Handle(state1) { //Do somethingB }
void Handle(state2) { //Do somethingC }
void Handle(other) {  //Do somethingD }

每当新增状态时，就需要添加if-else分支，修改原来的代码，违反“开闭原则”，而且大量的分支结构，使得代码难以理解与维护。

动机

• 在软件构建过程中，某些对象的状态如果改变，其行为也会随之而发生变化，比如文档处于只读状态，其支持的行为和读写状态支持的行为就可能完全不同。
• 如何在运行时根据对象的状态来透明地更改对象的行为？而不会为对象操作和状态转换之间引入紧耦合？

定义

允许一个对象在其内部状态改变时改变它的行为。从而使对象看起来似乎修改了其行为。　　——《设计模式》GOF

有了状态模式之后，可以解决随着状态增加而出现的多分支结构，将状态处理分散到各个状态子类中去，每个子类处理一种状态，因而使得状态的处理和转换变得清晰明确。

结构

Context：定义客户端感兴趣的接口，并且维护一个ConcreteState子类的实例，这个实例定义当前状态；
State：定义一个接口以封装与Context的一个特定状态相关的行为；
ConcreteState A/B：每一个子类实现一个与Context的一个状态相关的行为。

它们之间的协作步骤：

1. Context将与状态相关的请求委托给当前的ConcreteState对象处理；
2. Context可以将自身作为一个参数传递给处理该请求的状态对象。这使得状态对象可以在必要时访问Context；
3. Context是客户使用的主要接口。客户可用状态对象来配置一个Context，一旦一个Context配置完毕，它的客户不再需要直接与状态对象打交道。

代码实现：

#include <iostream>
using namespace std;

class Context;

//状态基类，为不同的状态规范统一的接口，当然可以有Handle1，Handle2...
class State {
   public:
    virtual void Handle(Context* pContext) = 0;
};

//如最开始的实例代码，将if-else拆散为不同状态下的Handle处理函数
class ConcreteStateA : public State {
   public:
    virtual void Handle(Context* pContext) { cout << "I am concreteStateA
"; }
};

class ConcreteStateB : public State {
   public:
    virtual void Handle(Context* pContext) { cout << "I am concreteStateB
"; }
};

//客户使用的主要接口。用状态对象来配置一个Context
class Context {
   public:
    Context(State* pState) : m_pState(pState) {}

    //根据多态的特性会实际调用到指定状态的处理函数
    void Request() {
        if (m_pState) {
            m_pState->Handle(this);
        }
    }

    void ChangState(State* pState) { m_pState = pState; }

   private:
    State* m_pState;
};

int main() {
    State* pStateA = new ConcreteStateA();
    State* pStateB = new ConcreteStateB();
    Context* pContext = new Context(pStateA);
    pContext->Request();
    pContext->ChangState(pStateB);
    pContext->Request();

    delete pContext;
    delete pStateB;
    delete pStateA;

    return 0;
}

总结

状态模式是利用多态的动态绑定特性消除了if-else的分支结构，将对象的状态与对应状态下的行为分离开来，每一个状态对应一个类，一个类集中管理一个状态，在多状态的情况下，简化程序的结构，易于扩展。
参考：

C++设计模式——状态模式