状态模式

状态模式

1. 概述

　　状态模式，就是将对象的状态和对应状态下的行为分离开来，不再是简单的if…else或switch…case分支结构了，而是每一个状态都对应一个类，一个类集中管理一个状态；在多状态的情况下，简化了程序的维护和管理，让程序结构简明化，同时也易于扩展。

2. 解决的问题

　　当控制一个对象状态转换的条件表达式过于复杂时的情况。

3. 模式中的角色

　　1） 上下文环境（Context）：定义了客户程序所需接口并维护一个具体状态角色实例，将与状态相关的操作委托给当前的ConcreteState对象处理。

　　2） 抽象状态（State）：定义一个接口以封装使用上下文环境的的一个特定状态相关的行为。

　　3） 具体状态（Concrete State）：实现抽象状态定义的接口。

4. 优点

　　1） 状态模式将与特定状态相关的行为局部化，并且将不同状态的行为分割开来。

　　2） 所有状态相关的代码都存在于某个ConcereteState中，所以通过定义新的子类很容易地增加新的状态和转换。

　　3） 状态模式通过把各种状态转移逻辑分不到State的子类之间，来减少相互间的依赖。

5. 缺点

　　1） 导致较多的ConcreteState子类

6. 适用场景

　　下面是GOF在《设计模式》中给出的状态模式的适用情况：

　　1） 一个对象的行为取决于它的状态, 并且它必须在运行时刻根据状态改变它的行为。

　　2） 一个操作中含有庞大的多分支的条件语句，且这些分支依赖于该对象的状态。

7. 与策略模式的比较

　　下面是策略模式和方法模式的UML图

                               

　　二者外表一样,只是二者的关注点不一样：

　　1） 策略模式关注行为的变化,但归根结底只有一个行为,变化的只是行为的实现。客户不关注这些.当新增变化时对客户可以没有任何影响。

　　2） 状态模式同样关注行为的变化，但这个变化是由状态来驱动，一般来说每个状态和行为都不同。客户需要关注新增的状态或行为与已有的不同。

　　状态模式一个形象的比喻是”饱了睡,饿了吃”.在这里”饱和饿”是两种状态,”睡和吃”是两种行为.

 

8.代码实现

1）用if...else的情况

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

void Action(State actionState)
{
    if (actionState == state)
    {
         // DoSomething
    }
    else if (actionState == state1)
    {
         // DoSomething
    }
    else if (actionState == state2)
    {
         // DoSomething
    }
    else
    {
         // DoSomething
    }
}

2）用状态模式表现--分离状态和行为

#include <iostream>
using namespace std;

class Context;
class State
{
public:
    virtual void Handle(Context *pContext) = 0;
};

class ConcreteStateA : public State
{
public:
    virtual void Handle(Context *pContext)
    {
         cout<<"I am concretestateA."<<endl;
    }
};
class ConcreteStateB : public State
{
public:
    virtual void Handle(Context *pContext)
    {
         cout<<"I am concretestateB."<<endl;
    }
};

class Context
{
public:
    Context(State *pState) : m_pState(pState){}
    void Request()
    {
         if (m_pState)
         {
              m_pState->Handle(this);
         }
    }
     void ChangeState(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->ChangeState(pStateB);
    pContext->Request();

    delete pContext;
    delete pStateB;
    delete pStateA;
}

3）状态模式--旋转开关

　　"一般的状态判断"如:

　　　　if (which==1) state="hello"; 　　　　

　　　　else if (which==2) state="hi"; 　　　　

　　　　else if (which==3) state="bye";

　　如果改成:

　　　　if (state.euqals("bye")) state="hello"; 　　　　

　　　　else if (state.euqals("hello")) state="hi"; 　　　　

　　　　else if (state.euqals("hi")) state="bye";

　　这就是 "开关切换状态",是将state的状态从"hello"切换到"hi",再切换到""bye";在切换到"hello",好象一个旋转开关,这种状态改变就可以使用State模式了.

.h文件:

class Context;
class State
{
public:
    virtual void Handle(Context* pContext)=0;
};

class ConcreteStateA : public State
{
public:
    virtual void Handle(Context* pContext);
};

class ConcreteStateB : public State
{
public:
    virtual void Handle(Context* pContext);
};

class ConcreteStateC : public State
{
public:
    virtual void Handle(Context* pContext);
};

class Context
{
public:
    Context(State* pState): m_pState(pState){}
    void Request()
    {
        if(m_pState)
    {
        m_pState->Handle(this);
    }
    }
    void ChangeState(State* pState)
    {
        m_pState = pState;
    }

private:
    State* m_pState;
};

.cpp文件

//执行该状态的行为并改变状态
void ConcreteStateA::Handle(Context* pContext)
{
    cout << "ConcreteStateA" << endl; 5     pContext->ChangeState(new ConcreteStateB());
}

//执行该状态的行为并改变状态
void ConcreteStateB::Handle(Context* pContext)
{
    cout << "ConcreteStateB" << endl;12     pContext->ChangeState(new ConcreteStateC());
}

//执行该状态的行为并改变状态
void ConcreteStateC::Handle(Context* pContext)
{
    cout << "ConcreteStateC" << endl;
    pContext->ChangeState(new ConcreteStateA());
}

客户端：

#include "State.h"

int main()
{
    State* pState = new ConcreteStateA();
    Context* pContext = new Context(pState);
    pContext->Request();
    pContext->Request();
    pContext->Request();
    pContext->Request();
    pContext->Request();
    return 0;
}