C++状态模式
<上一节
下一节>
由遇到的问题引出状态模式
每个人、事物在不同的状态下会有不同表现(动作),而一个状态又会在不同的表现下转移到下一个不同的状态(State)。最简单的一个生活中的例子就是:地铁入口处,如果你放入正确的地铁票,门就会打开让你通过。在出口处也是验票,如果正确你就可以 ok,否则就不让你通过(如果你动作野蛮,或许会有报警(Alarm),:))。有限状态自动机(FSM)也是一个典型的状态不同,对输入有不同的响应(状态转移)。
通常我们在实现这类系统会使用到很多的 Switch/Case 语句,Case 某种状态,发生什么动作,Case 另外一种状态,则发生另外一种状态。但是这种实现方式至少有以下两个问题:
- 当状态数目不是很多的时候,Switch/Case 可能可以搞定。但是当状态数目很多的时候(实际系统中也正是如此),维护一大组的 Switch/Case 语句将是一件异常困难并且容易出错的事情。
- 状态逻辑和动作实现没有分离。在很多的系统实现中,动作的实现代码直接写在状态的逻辑当中。这带来的后果就是系统的扩展性和维护得不到保证。
模式选择
状态模式就是被用来解决上面列出的两个问题的,在状态模式中我们将状态逻辑和动作实现进行分离。当一个操作中要维护大量的 case 分支语句,并且这些分支依赖于对象的状态。状态模式将每一个分支都封装到独立的类中。状态模式典型的结构图为:图 2-1:状态模式结构图
状态模式的实现
完整代码示例(code):状态模式实现上还是有些特点,这里为了方便初学者的学习和参考,将给出完整的实现代码(所有代码采用 C++实现,并在 VC 6.0 下测试运行)。代码片断 1:State.h
//state.h
#ifndef _STATE_H_
#define _STATE_H_
class Context; //前置声明
class State{
public:
State();
virtual ~State();
virtual void OperationInterface(Context* ) = 0;
virtual void OperationChangeState(Context*) = 0;
protected:
bool ChangeState(Context* con,State* st);
private:
//bool ChangeState(Context* con,State* st);
};
class ConcreteStateA:public State{
public:
ConcreteStateA();
virtual ~ConcreteStateA();
virtual void OperationInterface(Context* );
virtual void OperationChangeState(Context*);
protected:
private:
};
class ConcreteStateB:public State{
public:
ConcreteStateB();
virtual ~ConcreteStateB();
virtual void OperationInterface(Context* );
virtual void OperationChangeState(Context*);
protected:
private:
};
#endif //~_STATE_H_
代码片断 2:State.cpp
//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::OperationInterface
......"<<endl;
}
void ConcreteStateA::OperationChangeState(Context* con){
OperationInterface(con);
this->ChangeState(con,new ConcreteStateB());
}
///
ConcreteStateB::ConcreteStateB(){
}
ConcreteStateB::~ConcreteStateB(){
}
void ConcreteStateB::OperationInterface(Context* con){
cout<<"ConcreteStateB::OperationInterface......"<<endl;
}
void ConcreteStateB::OperationChangeState(Context* con){
OperationInterface(con);
this->ChangeState(con,new ConcreteStateA());
}
代码片断 3:Context.h
//context.h
#ifndef _CONTEXT_H_
#define _CONTEXT_H_
class State;
/**
*
**/
class Context{
public:
Context();
Context(State* state);
~Context();
void OprationInterface();
void OperationChangState();
protected:
private:
friend class State; //表明在 State 类中可以访问 Context 类的 private 字段
bool ChangeState(State* state);
private:
State* _state;
};
#endif //~_CONTEXT_H_
代码片断 4:Context.cpp
//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){
///_state->ChangeState(this,state);
this->_state = state;
return true;
}
void Context::OperationChangState(){
_state->OperationChangeState(this);
}
代码片断 5:main.cpp
//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->OperationChangState();
con->OperationChangState();
con->OperationChangState();
if (con != NULL)
delete con;
if (st != NULL)
st = NULL;
return 0;
}
代码说明:状态模式在实现中,有两个关键点:
- 将状态声明为 Context 的友元类(friend class),其作用是让状态模式访问 Context的 protected 接口 ChangeSate()。
- 状态及其子类中的操作都将 Context*传入作为参数,其主要目的是状态类可以通过这个指针调用 Context 中的方法(在本示例代码中没有体现)。这也是状态模式和 Strategy模式的最大区别所在。
运行了示例代码后可以获得以下的结果:连续 3 次调用了 Context 的 OprationInterface()因为每次调用后状态都会改变(A-B-A),因此该动作随着 Context 的状态的转变而获得了不同的结果。
关于状态模式的讨论
状态模式的应用也非常广泛,从最高层逻辑用户接口 GUI 到最底层的通讯协议(例如GoF 在《设计模式》中就利用状态模式模拟实现一个 TCP 连接的类。)都有其用武之地。状态模式和策略模式又很大程度上的相似:它们都有一个 Context 类,都是通过委托(组合)给一个具有多个派生类的多态基类实现 Context 的算法逻辑。两者最大的差别就是状态模式中派生类持有指向 Context 对象的引用,并通过这个引用调用 Context 中的方法,但在策略模式中就没有这种情况。因此可以说一个状态实例同样是策略模式的一个实例,反之却不成立。实际上状态模式和 Strategy 模式的区别还在于它们所关注的点不尽相同:状态模式主要是要适应对象对于状态改变时的不同处理策略的实现,而策略则主要是具体算法和实现接口的解耦(coupling),Strategy 模式中并没有状态的概念(虽然很多时候有可以被看作是状态的概念),并且更加不关心状态的改变了。状态模式很好地实现了对象的状态逻辑和动作实现的分离,状态逻辑分布在状态的派生类中实现,而动作实现则可以放在 Context 类中实现(这也是为什么状态派生类需要拥有一个指向 Context 的指针)。这使得两者的变化相互独立,改变状态的状态逻辑可以很容易复用 Context 的动作,也可以在不影响状态派生类的前提下创建 Context 的子类来更改或替换动作实现。
状态模式问题主要是逻辑分散化,状态逻辑分布到了很多的状态的子类中,很难看到整个的状态逻辑图,这也带来了代码的维护问题。
<上一节
下一节>