亲宝软件园·资讯

展开

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

梦在天涯 人气:0
想了解详解state状态模式及在C++设计模式编程中的使用实例的相关内容吗,梦在天涯在本文为您仔细讲解状态模式在C++中的使用实例的相关知识和一些Code实例,欢迎阅读和指正,我们先划重点:state,状态模式,C++,设计模式,下面大家一起来学习吧。

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

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

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

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

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

201639173716593.jpg (558×259)

状态模式的实现
代码片断 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过多出现的问题。

加载全部内容

相关教程
猜你喜欢
用户评论