State 模式-GoF 23 种设计模式精解系列-附 C++实现源码

前言

尊重原创，本系列文本解析部分主要基于Candidate for Master’s Degree School of Computer Wuhan University的K_Eckel（[email protected]）《设计模式精解-GoF 23 种设计模式解析附 C++实现源码》。为了避免重造轮子，本系列博文对源码在ubuntu16.04下做了验证并上传到了gitee，再次感谢。

如有问题，可邮件联系我([email protected])并共同探讨解决方案。

State 模式简介：

在状态模式（State Pattern）中，类的行为是基于它的状态改变的。这种类型的设计模式属于行为型模式。
在状态模式中，我们创建表示各种状态的对象和一个行为随着状态对象改变而改变的 context 对象。比如打篮球的时候运动员可以有正常状态、不正常状态和超常状态。

问题：

每个人、事物在不同的状态下会有不同表现（动作），而一个状态又会在不同的表现下转移到下一个不同的状态（State）。最简单的一个生活中的例子就是：地铁入口处，如果你放入正确的地铁票，门就会打开让你通过。在出口处也是验票，如果正确你就可以ok，否则就不让你通过，如果你动作野蛮，或许会有报警（Alarm）。
有限状态自动机（FSM）也是一个典型的状态不同，对输入有不同的响应（状态转移）。通常我们在实现这类系统会使用到很多的Switch/Case语句，Case某种状态，发生什么动作，Case另外一种状态，则发生另外一种状态。但是这种实现方式至少有以下两个问题：

当状态数目不是很多的时候，Switch/Case 可能可以搞定。但是当状态数目很多的时候（实际系统中也正是如此），维护一大组的1Switch/Case1 语句将是一件异常困难并且容易出错的事情。
状态逻辑和动作实现没有分离。在很多的系统实现中，动作的实现代码直接写在状态的逻辑当中。这带来的后果就是系统的扩展性和维护得不到保证。

模式选择

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

实现

完整代码示例（code）

State模式实现上还是有些特点，这里为了方便初学者的学习和参考，将给出完整的实现代码(所有代码采用 C++实现,并在 Visual Studio Code，Version: 1.36.1 下测试运行)。

源码gitee地址：点击这里

代码目录结构：

PS C:\Users\guopz\Desktop\GiteeBlog\designpatternsbycpipei\behavioralPattern\State> tree /F
卷 Windows 的文件夹 PATH 列表
卷序列号为 F0C5-AFA6
C:.
├─include
│      Context.h
│      State.h
│
└─src
        a.out
        Context.cpp
        main.cpp
        State.cpp

PS C:\Users\guopz\Desktop\GiteeBlog\designpatternsbycpipei\behavioralPattern\State>

Context.h:

// Context.h

#ifndef _CONTEXT_H_
#define _CONTEXT_H_

class State;

class Context {
 private:
  //表明在 State 类中可以访问 Context 类的 private 字段
  friend class State;
  bool ChangeState(State* state);
  State* _state;

 public:
  Context(/* args */);
  Context(State* state);
  ~Context();

  void OprationInterface();
  void OperationChangState();
};

#endif //~_CONTEXT_H_

State.h:

// State.h

#ifndef _STATE_H_
#define _STATE_H_

class Context;  //前置声明

class State {
 private:
  /* data */

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

 public:
  State(/* args */);
  virtual ~State();
  virtual void OperationInterface(Context*) = 0;
  virtual void OperationChangeState(Context*) = 0;
};

class ConcreteStateA:public State
{
private:
    /* data */
public:
    ConcreteStateA(/* args */);
    virtual ~ConcreteStateA();
    virtual void OperationInterface(Context*);
    virtual void OperationChangeState(Context*);
};

class ConcreteStateB:public State
{
private:
    /* data */
public:
    ConcreteStateB(/* args */);
    ~ConcreteStateB();
    virtual void OperationInterface(Context*);
    virtual void OperationChangeState(Context*);
};

#endif //~_STATE_H_

Context.cpp:

// Context.cpp

#include "../include/Context.h"
#include "../include/State.h"

Context::Context(/* args */) {}
Context::Context(State* state) { this->_state = state; }
Context::~Context() { delete _state; }
void Context::OprationInterface() { _state->OperationChangeState(this); }
bool Context::ChangeState(State* state) {
  this->_state = state;
  return true;
}
void Context::OperationChangState() { _state->OperationChangeState(this); }

State.cpp:

// State.cpp

#include "../include/State.h"
#include <iostream>
#include "../include/Context.h"

using namespace std;

State::State(/* args */) {}
State::~State() {}
void State::OperationInterface(Context* con) { printf("State::.. \n"); }
bool State::ChangeState(Context* con, State* st) {
  con->ChangeState(st);

  return true;
}
void State::OperationChangeState(Context* con) {}

ConcreteStateA::ConcreteStateA(/* args */) {}
ConcreteStateA::~ConcreteStateA() {}
void ConcreteStateA::OperationInterface(Context* con) {
  printf("ConcreteStateA::OperationInterface... \n");
}
void ConcreteStateA::OperationChangeState(Context* con) {
  OperationInterface(con);
  this->ChangeState(con, new ConcreteStateB());
}

ConcreteStateB::ConcreteStateB(/* args */) {}
ConcreteStateB::~ConcreteStateB() {}
void ConcreteStateB::OperationInterface(Context* con) {
  printf("ConcreteStateB::OperationInterface... \n");
}
void ConcreteStateB::OperationChangeState(Context* con) {
  OperationInterface(con);
  this->ChangeState(con, new ConcreteStateA());
}

main.cpp:

//main.cpp

#include "../include/Context.h"
#include "../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;
}

代码说明

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

将State声明为Context的友元类（friend class），其作用是让State模式访问Context的protected接口ChangeSate（）。
State及其子类中的操作都将Context*传入作为参数，其主要目的是State类可以通过这个指针调用Context中的方法（在本示例代码中没有体现）。这也是State模式和Strategy模式的最大区别所在。
运行了示例代码后可以获得以下的结果：连续3次调用了Context的OprationInterface（）因为每次调用后状态都会改变（A－B－A），因此该动作随着Context的状态的转变而获得了不同的结果。

编译运行结果：

PS C:\Users\guopz\Desktop\GiteeBlog\designpatternsbycpipei\behavioralPattern\State\src> g++ *.cpp -std=c++11
PS C:\Users\guopz\Desktop\GiteeBlog\designpatternsbycpipei\behavioralPattern\State\src> .\a.exe
ConcreteStateA::OperationInterface...
ConcreteStateB::OperationInterface...
ConcreteStateA::OperationInterface...
PS C:\Users\guopz\Desktop\GiteeBlog\designpatternsbycpipei\behavioralPattern\State\src>

讨论

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的子类中，很难看到整个的状态逻辑图，这也带来了代码的维护问题。

前言

目录

创建型模式(Creating Pattern)

结构型模式（Structrual Pattern）

行为型模式（Behavioral Pattern）