设计模式(20)-行为型模式-State模式

3.8.1 功能

State模式被用来解决下面列出的两个问题：

1）当状态数目不是很多的时候，Switch/Case可能可以搞定。但是当状态数目很多的时候（实际系统中也正是如此），维护一大组的Switch/Case语句将是一件异常困难并且容易出错的事情。

2）状态逻辑和动作实现没有分离。在很多的系统实现中，动作的实现代码直接写在状态的逻辑当中。这带来的后果就是系统的扩展性和维护得不到保证。

3.8.2 结构

•C o n t e x t( 环境，如TC P C o n n e c t i o n )
                — 定义客户感兴趣的接口。

                — 维护一个Co n c r e t e S t a t e子类的实例，这个实例定义当前状态。

•  S t a t e( 状态，如T C P S t a t e )

                — 定义一个接口以封装与C o n t e x t的一个特定状态相关的行为。

•  ConcreteState subclasses(具体状态子类，如 TCPEstablished,TCPListen, TCPClosed)

                — 每一子类实现一个与C o n t e x t的一个状态相关的行为。

 

协作：

•C o n t e x t将与状态相关的请求委托给当前的C o n c r e t e S t a t e对象处理。
•C o n t e x t可将自身作为一个参数传递给处理该请求的状态对象。这使得状态对象在必要时可访问Co n t e x t。
•C o n t e x t是客户使用的主要接口。客户可用状态对象来配置一个C o n t e x t ，一旦一个Co n t e x t配置完毕,  它的客户不再需要直接与状态对象打交道。
•C o n t e x t或Co n c r e t e S t a t e子类都可决定哪个状态是另外哪一个的后继者，以及是在何种条件下进行状态转换。

3.8.3 C++代码示例

//state.h

#ifndef _STATE_H_

#define _STATE_H_

classContext;//前置声明

classState

{

public:

       State();

       virtual ~State();

       virtual  void

              OperationInterface(Context*) = 0;

       virtual  void

              OperationChangeState(Context*) =0;

protected:

       bool ChangeState(Context*con, State*

              st);

private:

       //boolChangeState(Context* con,State*

       st);

};

ClassConcreteStateA:public State

{

public:

       ConcreteStateA();

       virtual ~ConcreteStateA();

       virtual  void

              OperationInterface(Context*);

       virtual  void

              OperationChangeState(Context*);

protected:

private:

};

classConcreteStateB:public State

{

public:

       ConcreteStateB();

       virtual ~ConcreteStateB();

       virtual  void

              OperationInterface(Context*);

       virtual  void

              OperationChangeState(Context*);

protected:

private:

};

#endif //~_STATE_H_

 

//State.cpp

#include"State.h"

#include"Context.h"

#include<iostream>

using namespace std;

State::State()

{

}

State::~State()

{

}

void State::OperationInterface(Context*con)

{

       cout << "State::.."<< endl;

}

bool State::ChangeState(Context* con, State*st)

{

       con->ChangeState(st);

       return true;

}

void State::OperationChangeState(Context*

       con)

{

}

ConcreteStateA::ConcreteStateA()

{

}

ConcreteStateA::~ConcreteStateA()

{

}

void

ConcreteStateA::OperationInterface(Context*

con)

{

       cout << "ConcreteStateA::OperationInterfa

              ce......"<<endl;

}

void

ConcreteStateA::OperationChangeState(Contex

t*con)

{

       OperationInterface(con);

       this->ChangeState(con, new

              ConcreteStateB());

}

ConcreteStateB::ConcreteStateB()

{

}

ConcreteStateB::~ConcreteStateB()

{

}

void

ConcreteStateB::OperationInterface(Context*

con)

{

       cout << "ConcreteStateB::OperationInterfa

              ce......"<<endl;

}

void

ConcreteStateB::OperationChangeState(Contex

t*con)

{

       OperationInterface(con);

       this->ChangeState(con, new

              ConcreteStateA());

}

//context.h

#ifndef _CONTEXT_H_

#define _CONTEXT_H_

classState;

classContext

{

public:

       Context();

       Context(State* state);

       ~Context();

       void OprationInterface();

       void OperationChangState();

protected:

private:

       friend classState; //表明在State类中可

       以访问Context类的private字段

              bool ChangeState(State*state);

private:

       State* _state;

};

#endif //~_CONTEXT_H_

//context.cpp

#include"Context.h"

#include"State.h"

Context::Context()

{

}

Context::Context(State*state)

{

       this->_state = state;

}

Context::~Context()

{

       delete _state;

}

void Context::OprationInterface()

{

       _state->OperationInterface(this);

}

bool Context::ChangeState(State* state)

{

       this->_state = state;

       return true;

}

void Context::OperationChangState()

{

       _state->OperationChangeState(this);

}

 

//main.cpp

#include"Context.h"

#include"State.h"

#include<iostream>

using namespace std;

int main(int argc,char*argv[])

{

       State* st = new ConcreteStateA();

       Context* con = new Context(st);

       con->OprationInterface();

       con->OprationInterface();

       con->OprationInterface();

       if (con != NULL)

              delete con;

       if (st != NULL)

              st = NULL;

       return 0;

}