详解state状态模式及在C++设计模式编程中的使用实例

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

有限状态自动机(FSM)也是一个典型的状态不同,对输入有不同的响应(状态转移)。

通常我们在实现这类系统会使用到很多的 Switch/Case 语句,Case 某种状态,发生什么动作,Case 另外一种状态,则发生另外一种状态。但是这种实现方式至少有以下两个问题:
当状态数目不是很多的时候,Switch/Case 可能可以搞定。但是当状态数目很多的时候(实际系统中也正是如此),维护一大组的 Switch/Case 语句将是一件异常困难并且容易出错的事情。
状态逻辑和动作实现没有分离。在很多的系统实现中,动作的实现代码直接写在状态的逻辑当中。这带来的后果就是系统的扩展性和维护得不到保证。

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

状态模式典型的结构图为:

状态模式的实现
代码片断 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;
}

代码说明:状态模式在实现中,有两个关键点:
1.将状态声明为 Context 的友元类(friend class),其作用是让状态模式访问 Context的 protected 接口 ChangeSate()。
状态及其子类中的操作都将 Context*传入作为参数,其主要目的是状态类可以通过这个指针调用 Context 中的方法(在本示例代码中没有体现)。这也是状态模式和 Strategy模式的最大区别所在。

2.运行了示例代码后可以获得以下的结果:连续 3 次调用了 Context 的 OprationInterface()因为每次调用后状态都会改变(A-B-A),因此该动作随着 Context 的状态的转变而获得了不同的结果。

关于State模式的一些需要注意的地方
这个模式使得软件可以在不同的state下面呈现出完全不同的特征

不同的theme使得相同的元素呈现出不同的特点
不同的state下面相同的操作产生不同的效果
不同的状态对相同的信息产生不同的处理
这个模式使得操作的state逻辑更加的清楚,省去了无数的state判断,而state的扩展性和可维护性和执行效率也大幅度的上升。关于state,有如下几点要注意的地方:

1.所有的state应该被一个类(State Manager Class)管理:

state之间的跳转和转换是非常复杂的,有时一些state可能要跳转的目标state有几十个,这个时候我们需要一个管理类(State Manager )来统一的管理这些state的切换,例如目标state的初始化和申请跳转state的结束处理,以及一些state间共享数据的存储和处理。与其称这个Manager 为管理类,不如说是一个中间类,它实现了state之间的解隅,使得各个state之间不比知道target state的具体信息,而只要向Manager申请跳转就可以了。使得各个state的模块化更好,更加的灵活

2.所有的state都应该从一个state基类继承:

既然state要教给一个manager来管理,那么自然的,这些state都应该从一个父类继承下来,这样manager并不需要知道很多子类的信息,一个最单纯的manager只要只要管理一个这样的基类的指针就可以了。另外,我们还可以统一的把state的一些共有的属性放在这里

3.state应该实现为一个singleton:

state并不需要总是被申请,这样可能会造成管理上的混乱,state资源的申请也不应该可以任意进行,事实上,state的申请权限应该只有 Manager才有,并且有且只有一次。在这样的情况下,state的构造函数似乎应该被声明为protected or private ,而Manager应该被声明为state的友元,但是友元被看成是破坏类的封装性的一种做法,这一点上,我很矛盾,所以在这一条上我只能采取一种漠视的态度。

4.应该做一个state么?这是一个问题:

state可以说是if-else的一种替代品,极端的情况下面state可以让你的程序中if-else程序块消失得无影无踪,但是,这并不是银弹。state对于状态可预知的情况下非常有效,但是对于state不可预知,或者相似的state数量太多。过多的state会造成class的粒度过细,程序反而不简洁。在这样的情况下,你应该考虑使用if-else程序块来替代state。

例如:

有这样的一个程序,它可以生成任意形状的多边形,而多边形的各个节点是可以移动的,问题就来了。

我并不知道用户将要使用多少个节点的多边形,因此我无法的创建那么多相应的state来使得这样一个程序正常工作。state大多数都是确定的,对于不确定的,state似乎无能为力,例如此例

一种解决方法是我利用Manager传递给state一个state参数,让state有机会知道用户的操作意图,在这个例子里面是让state知道用户打算操作某一个节点,而state根据这个state参数来处理用户的操作,比如说,state得到的是用户操作的某一个点的index ,而state只要写

points[index].moveTo(points[index].getX()+offset_x , points[index].getY()+offset_y);

就可以,从而避免了state过多出现的问题。

(0)

相关推荐

  • 详解PHP中的状态模式编程

    定义 状态模式,又称状态对象模式(Pattern of Objects for State),状态模式就是对象的行为模式.状态模式允许一个对象在其内部状态改变的时候改变其行为.这个对象看上去就像是改变了它的类一样 UML图 状态模式中主要角色 抽象状态角色(State):定义一个接口或抽象类State,用以封装环境对象的一个特定的状态所对应的行为 具体状态(ConcreteState)角色:每一个状态类都实现了环境(Context)的一个状态所对应的行为 环境(Context)角色:定义客户端所

  • 对比Java设计模式编程中的状态模式和策略模式

    为了能在Java应用程序中正确的使用状态模式和策略模式,开发人员需要清楚地知道这两种模式之间的区别.尽管状态模式和策略模式的结构非常相似,它们又同样遵循开闭原则,都代表着SOLID设计原则的'O',但它们的意图是完全不同的.Java中的策略模式是对一组相关的算法进行封装,给调用方提供了运行时的灵活性.调用方可以在运行时选择不同的算法,而不用修改使用策略的那个Context类.使用策略模式的经典例子包括实现加密算法,压缩算法,以及排序算法.另一方面,状态模式使用一个对象可以在不同的状态下表现出不同

  • php设计模式 State (状态模式)

    状态state模式是GOF23种模式中的一种,和命令模式一样,也是一种行为模式.状态模式和命令模式相当像,一样是"接口-实现类"这种模式的应用,是面向接口编程原则的体现. 状态模式属于对象创建型模式,其意图是允许一个对象在其内部状态改变时改变它的行为,对象看起来似乎修改了他的类.比较常见的例子是在一个表示网络连接的类TCPConnection,一个TCPConnection对象的状态处于若干不同的状态之一:连接已经建立(Established),正在监听,连接已经关闭(closed).

  • 学习php设计模式 php实现状态模式

    一.意图 允许一个对象在其内部状态改变时改变它的行为.对象看起来似乎修改了它的类 状态模式变化的位置在于对象的状态 二.状态模式结构图   三.状态模式中主要角色 抽象状态(State)角色:定义一个接口,用以封装环境对象的一个特定的状态所对应的行为 具体状态(ConcreteState)角色:每一个具体状态类都实现了环境(Context)的一个状态所对应的行为 环境(Context)角色:定义客户端所感兴趣的接口,并且保留一个具体状态类的实例.这个具体状态类的实例给出此环境对象的现有状态 四.

  • Java设计模式之状态模式(State模式)介绍

    State的定义:不同的状态,不同的行为:或者说,每个状态有着相应的行为. 何时使用状态模式 State模式在实际使用中比较多,适合"状态的切换".因为我们经常会使用If elseif else 进行状态切换, 如果针对状态的这样判断切换反复出现,我们就要联想到是否可以采取State模式了. 不只是根据状态,也有根据属性.如果某个对象的属性不同,对象的行为就不一样,这点在数据库系统中出现频率比较高,我们经常会在一个数据表的尾部,加上property属性含义的字段,用以标识记录中一些特殊

  • 轻松掌握JavaScript状态模式

    状态模式 状态模式(State)允许一个对象在其内部状态改变的时候改变它的行为,对象看起来似乎修改了它的类. 状态模式的使用场景也特别明确,有如下两点:  1.一个对象的行为取决于它的状态,并且它必须在运行时刻根据状态改变它的行为.(有些对象通常会有好几个状态,在每个状态都只可以做当前状态才可以做的事情,而不能做其它状态能做的事儿) 2.一个操作中含有大量的分支语句,而且这些分支语句依赖于该对象的状态.状态通常为一个或多个枚举常量的表示. 一.有限状态机 1.状态总数(state)是有限的.  

  • 深入理解JavaScript系列(43):设计模式之状态模式详解

    介绍 状态模式(State)允许一个对象在其内部状态改变的时候改变它的行为,对象看起来似乎修改了它的类. 正文 举个例子,就比如我们平时在下载东西,通常就会有好几个状态,比如准备状态(ReadyState).下载状态(DownloadingState).暂停状态(DownloadPausedState).下载完毕状态(DownloadedState).失败状态(DownloadFailedState),也就是说在每个状态都只可以做当前状态才可以做的事情,而不能做其它状态能做的事儿. 由于Stat

  • C++设计模式之状态模式

    前言 在实际开发中,我们经常会遇到这种情况:一个对象有多种状态,在每一个状态下,都会有不同的行为.那么在代码中我们经常是这样实现的. 复制代码 代码如下: typedef enum tagState {      state,      state1,      state2 }State;   void Action(State actionState) {      if (actionState == state)      {           // DoSomething     

  • iOS App的设计模式开发中对State状态模式的运用

    1.概述 在软件开发过程中,应用程序可能会根据不同的情况作出不同的处理.最直接的解决方案是将这些所有可能发生的情况全都考虑到.然后使用if... ellse语句来做状态判断来进行不同情况的处理.但是对复杂状态的判断就显得"力不从心了".随着增加新的状态或者修改一个状体(if else(或switch case)语句的增多或者修改)可能会引起很大的修改,而程序的可读性,扩展性也会变得很弱.维护也会很麻烦.那么我就考虑只修改自身状态的模式. 例子1:按钮来控制一个电梯的状态,一个电梯开们,

  • 学习JavaScript设计模式之状态模式

    状态模式的关键是区分事物内部的状态,事物内部状态的改变往往会带来事物的行为改变. 当电灯开着,此时按下开关,电灯会切换到关闭状态:再按一次开关,电灯又将被打开.同一个开关在不同的状态下,表现出来的行为是不一样的. 一.有限状态机 状态总数(state)是有限的. 任一时刻,只处在一种状态之中. 某种条件下,会从一种状态转变(transition)到另一种状态. 允许一个对象在其内部状态改变时改变它的行为,对象看起来似乎修改了它的类. 解释: (1)将状态封装成独立的类,并将请求委托给当前的状态对

随机推荐