设计模式解析之——State模式（k_eckel转自微软高校博客K_eckel's mindview）

0 引言

0.1 目的

       本文档给出设计模式之——State模式的简化诠释，并给出其C++实现。

0.2 说明

Project	Design Pattern Explanation（By K_Eckel）
Authorization	Free Distributed but Ownership Reserved
Date	2005-04-05（Cherry blossom is Beautiful）
Test Bed	MS Visual C++ 6.0

0.3 参考

       在本文档的写作中，参考了以下的资源，在此列出表示感谢：

u       书籍

[GoF 2000]：GoF,Design Patterns-Elements of Reusable Object-Oriented Software

Addison-Wesley 2000/9.

        [Martine 2003]：Robert C.Martine, Agile Software Development Principles, Patterns, and Practices, Pearson Education, 2003.

0.4 联系作者

Author	K_Eckel
State	Candidate for Master’s Degree School of Computer Wuhan University
E_mail	frwei@whu.edu.cn

2 State模式

2.1 问题

每个人、事物在不同的状态下会有不同表现（动作），而一个状态又会在不同的表现下转移到下一个不同的状态（State）。最简单的一个生活中的例子就是：地铁入口处，如果你放入正确的地铁票，门就会打开让你通过。在出口处也是验票，如果正确你就可以ok，否则就不让你通过（如果你动作野蛮，或许会有报警（Alarm），：））。

有限状态自动机（FSM）也是一个典型的状态不同，对输入有不同的响应（状态转移）。通常我们在实现这类系统会使用到很多的Switch/Case语句，Case某种状态，发生什么动作，Case另外一种状态，则发生另外一种状态。但是这种实现方式至少有以下两个问题：

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

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

2.2 模式选择

       State模式就是被用来解决上面列出的两个问题的，在State模式中我们将状态逻辑和动作实现进行分离。当一个操作中要维护大量的case分支语句，并且这些分支依赖于对象的状态。State模式将每一个分支都封装到独立的类中。State模式典型的结构图为：

图2-1：State Pattern结构图

   

2.3 实现

2.3.1 完整代码示例（code）

       State模式实现上还是有些特点，这里为了方便初学者的学习和参考，将给出完整的实现代码（所有代码采用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;
}

 

2.3.2 代码说明

       State模式在实现中，有两个关键点：

       1）将State声明为Context的友元类（friend class），其作用是让State模式访问Context的protected接口ChangeSate（）。

       2）State及其子类中的操作都将Context*传入作为参数，其主要目的是State类可以通过这个指针调用Context中的方法（在本示例代码中没有体现）。这也是State模式和Strategy模式的最大区别所在。

       运行了示例代码后可以获得以下的结果：连续3次调用了Context的OprationInterface（）因为每次调用后状态都会改变（A－B－A），因此该动作随着Context的状态的转变而获得了不同的结果。

2.4 讨论

       State模式的应用也非常广泛，从最高层逻辑用户接口GUI到最底层的通讯协议（例如GoF在《设计模式》中就利用State模式模拟实现一个TCP连接的类。）都有其用武之地。

       State模式和Strategy模式又很大程度上的相似：它们都有一个Context类，都是通过委托（组合）给一个具有多个派生类的多态基类实现Context的算法逻辑。两者最大的差别就是State模式中派生类持有指向Context对象的引用，并通过这个引用调用Context中的方法，但在Strategy模式中就没有这种情况。因此可以说一个State实例同样是Strategy模式的一个实例，反之却不成立。实际上State模式和Strategy模式的区别还在于它们所关注的点不尽相同：State模式主要是要适应对象对于状态改变时的不同处理策略的实现，而Strategy则主要是具体算法和实现接口的解耦（coupling），Strategy模式中并没有状态的概念（虽然很多时候有可以被看作是状态的概念），并且更加不关心状态的改变了。

       State模式很好地实现了对象的状态逻辑和动作实现的分离，状态逻辑分布在State的派生类中实现，而动作实现则可以放在Context类中实现（这也是为什么State派生类需要拥有一个指向Context的指针）。这使得两者的变化相互独立，改变State的状态逻辑可以很容易复用Context的动作，也可以在不影响State派生类的前提下创建Context的子类来更改或替换动作实现。

       State模式问题主要是逻辑分散化，状态逻辑分布到了很多的State的子类中，很难看到整个的状态逻辑图，这也带来了代码的维护问题。