状态模式----C++实现

状态模式

定义：

允许一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它的类。

实用性：

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

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

优点：

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

2、 使得状态转换显示化。

3、 状态对象可以被共享。

结构：

实现：

class Context;

class State

{

public:

State(string name):m_name(name)

{ }

virtual void Handle(Context *pContext)

{ }

virtual~State()

{ }

string GetStateName()

{

returnm_name;

}

protected:

voidChangeState(Context *pContext,State *pState);

private:

string m_name;

};

class Context

{

public:

voidRequest()

{

m_pCurrentState->Handle(this);

}

voidSetCurrentState(State *pState)

{

cout<<"设置当前状态为 :"<GetStateName()<<endl;< p="">

m_pCurrentState = pState;

}

State *GetCurrentState()

{

cout<<"当前状态为 :"<<m_pcurrentstate->GetStateName()<<endl;< p="">

returnm_pCurrentState;

}

protected:

friend class State;

void ChangeState(State *pState)

{

cout<<"当前状态由 : "<<m_pcurrentstate->GetStateName()<<" 转变为状态："<GetStateName()<<endl;< p="">

m_pCurrentState = pState;

}

private:

State *m_pCurrentState;

};

voidState::ChangeState(Context *pContext,State *pState)

{

pContext->ChangeState(pState);

}

//状态子类可以共享，所以用单例模式，这里就忽略内存释放的问题了

class ConcreteStateA;

class ConcreteStateC:public State

{

public:

staticState* GetStateAInstance()

{

if(m_pInstance == NULL)

{

m_pInstance = new ConcreteStateC("状态 C");

}

returnm_pInstance;

}

voidHandle(Context *pContext);

private:

ConcreteStateC(string name):State(name)

{ }

staticConcreteStateC *m_pInstance;

};

class ConcreteStateB:public State

{

public:

staticState* GetStateAInstance()

{

if(m_pInstance == NULL)

{

m_pInstance = new ConcreteStateB("状态 B");

}

returnm_pInstance;

}

voidHandle(Context *pContext)

{

cout<<"状态 B 处理的业务逻辑"<<endl;< p="">

ChangeState(pContext,ConcreteStateC::GetStateAInstance());

}

private:

ConcreteStateB(string name):State(name)

{ }

staticConcreteStateB *m_pInstance;

};

class ConcreteStateA:public State

{

public:

staticState* GetStateAInstance()

{

if(m_pInstance == NULL)

{

m_pInstance = new ConcreteStateA("状态 A");

}

returnm_pInstance;

}

voidHandle(Context *pContext)

{

cout<<"状态 A 处理的业务逻辑"<<endl;< p="">

ChangeState(pContext,ConcreteStateB::GetStateAInstance());

}

private:

ConcreteStateA(string name):State(name)

{ }

staticConcreteStateA *m_pInstance;

};

voidConcreteStateC::Handle(Context *pContext)

{

cout<<"状态 C 处理的业务逻辑"<<endl;< p="">

ChangeState(pContext,ConcreteStateA::GetStateAInstance());

}

ConcreteStateA*ConcreteStateA::m_pInstance = NULL;

ConcreteStateB*ConcreteStateB::m_pInstance = NULL;

ConcreteStateC*ConcreteStateC::m_pInstance = NULL;

Context *pContext = new Context;

pContext->SetCurrentState(ConcreteStateA::GetStateAInstance());

pContext->Request();

pContext->Request();

pContext->Request();