状态模式(state)C++实现

状态模式(state)C++实现

什么是状态模式

状态模式：当一个对象的内在状态改变时允许改变其行为，这个对象看起来像是改变了这个类

状态模式的主要解决的是，当控制一个对象状态转换的条件表达式过于复杂时的情况。把状态的判断逻辑转移到表示不同状态的一系列类当中，可以把复杂的判断逻辑简化。当然，如果这个状态判断逻辑很简单，就没有必要使用状态模式了
这里对于简单逻辑判断和复杂逻辑判断，大家可以自己考虑，注意
1.当状态数目不是很多的时候，Switch/Case可能可以搞定。但是当状态数目很多的时候（实际系统中也正是如此），维护一大组的Switch/Case语句将是一件异常困难并且容易出错的事情。
2.状态逻辑和动作实现没有分离。在很多的系统实现中，动作的实现代码直接写在状态的逻辑当中。这带来的后果就是系统的扩展性和维护得不到保证。

角色分配

角色	角色作用	角色成员
State	用来实现每种状态的具体行为	一个行为接口用于与Context状态相关
State1	继承State状态	实现一个具体行为
…	…	…
Context	维护一个具体State状态实例，这个实例是当前状态	Request接口，用来调用State中行为接口，以及ChangeState接口

代码实现如下

#ifndef INCLUDE_CONTEXT_H_
#define INCLUDE_CONTEXT_H_
class Context;
class State \\抽象状态类
{
public:
    virtual void handle(Context* pContext) = 0;
    ~State(){}
protected:
    State(){}
};

class Context \\Contexte类要维护一个具体state类的实例，这个实例定义当前的状态
{
private:
    State* state;
public:
    Context(State* state):state(state){}
    void Request();
    void ChangeState(State* state);
};

class StateA : public State
{
public:
    StateA(){}
    ~StateA(){}
    virtual void handle(Context* pContext);
};

class StateB : public State
{
public:
    StateB(){}
    ~StateB(){}
    virtual void handle(Context* pContext);
};

class StateC : public State
{
public:
    StateC(){}
    ~StateC(){}
    virtual void handle(Context* pContext);
};

#endif /* INCLUDE_CONTEXT_H_ */

#include"Context.h"
#include


void Context::Request()
{
    state->handle(this);
}
void Context::ChangeState(State* state)
{
    this->state = state;
}



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


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


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

#include"Context.h"
#include


void Context::Request()
{
    state->handle(this);
}
void Context::ChangeState(State* state)
{
    this->state = state;
}



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


void StateB::handle(Context* pContext)
{
    std::cout << "StateB" << std::endl;
    pContext->ChangeState(new StateC());
}


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

#include
#include"Context.h"
using namespace std;


int main()
{
    State* pState = new StateA();
    Context* pContext = new Context(pState);

    pContext->Request();
    pContext->Request();

    pContext->Request();

    pContext->Request();

    pContext->Request();


    return 0;
}

输出

StateA
StateB
StateB
StateA
StateB

自己可以加入很多功能；
将特定的状态相关的行为都封装在一个对象中，由于所有与状态相关的代码都存在于一个具体的State中，所以定义新的子类很容易增加新的状态和转换。
说白了，为了消除庞大的条件分支语句。符合设计模式。