每个人、事物在不同的状态下会有不同表现（动作），而一个状态又会在不同的表现下转移到下一个不同的状态（State）。最简单的一个生活中的例子就是：地铁入口处，如果你放入正确的地铁票，门就会打开让你通过。在出口处也是验票，如果正确你就可以 ok，否则就不让你通过。通常我们在实现这类系统会使用到很多的 Switch/Case 语句，Case 某种状态，发生什么动作，Case 另外一种状态，则发生另外一种状态。但是这种实现方式也存在部分缺点：
1）当状态数目不是很多的时候，Switch/Case 可能可以搞定。但是当状态数目很多的时候（实际系统中也正是如此），维护一大组的 Switch/Case 语句将是一件异常困难并且容易出错的事情。
2）状态逻辑和动作实现没有分离。在很多的系统实现中，动作的实现代码直接写在状态的逻辑当中。这带来的后果就是系统的扩展性和维护得不到保证。
State 模式就是被用来解决上述问题的，在 State 模式中我们将状态逻辑和动作实现进行分离。当一个操作中要维护大量的 case 分支语句，并且这些分支依赖于对象的状态。State 模式将每一个分支都封装到独立的类中。UML图如下：
代码如下（示例）：
#pragma once
#ifndef _STATE_H_
#define _STATE_H_
#include <iostream>
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_
代码如下（示例）：
#include "State.h"
#include "Context.h"
State::State()
{
}
State::~State()
{
}
void State::OperationInterface(Context* con)
{
std::cout << "State::.." << std::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)
{
std::cout << "ConcreteStateA::OperationInterface ......"<<std::endl;
}
void ConcreteStateA::OperationChangeState(Context* con)
{
OperationInterface(con);
this->ChangeState(con, new ConcreteStateB());
}
///
ConcreteStateB::ConcreteStateB()
{
}
ConcreteStateB::~ConcreteStateB()
{
}
void ConcreteStateB::OperationInterface
(Context* con)
{
std::cout << "ConcreteStateB::OperationInterface......" << std::endl;
}
void ConcreteStateB::OperationChangeState(Context* con)
{
OperationInterface(con);
this->ChangeState(con, new ConcreteStateA());
}
代码如下（示例）：
#pragma once
#ifndef _CONTEXT_H_
#define _CONTEXT_H_
#include<iostream>
class State;
class Context
{
public:
Context();
Context(State* state);
~Context();
void OprationInterface();
void OperationChangState();
bool ChangeState(State* state);
protected:
private:
State* _state;
};
#endif //_CONTEXT_H_
代码如下（示例）：
#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);
}
代码如下（示例）：
#include "Context.h"
#include "State.h"
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;
}
State 模式在实现中，有两个关键点：
1）将 State 声明为 Context 的友元类（friend class），其作用是让 State 模式访问 Context 的 protected 接口 ChangeSate。
2）State 及其子类中的操作都将 Context*传入作为参数，其主要目的是 State 类可以通过这个指针调用 Context 中的方法（在本示例代码中没有体现）。这也是 State 模式和 Strategy模式的最大区别所在。
State模式运行结果如下：
从上述内容可以看出， State 模式和 Strategy 模式又很大程度上的相似：它们都有一个 Context 类，都是通过组合的方式给一个具有多个派生类的多态基类实现 Context 的算法逻辑。
两者最大的差别就是 State 模式中派生类持有指向 Context 对象的引用，并通过这个引用调用 Context 中的方法，但在 Strategy 模式中就没有这种情况。实际上 State 模式和 Strategy 模式的区别还在于它们所关注的点不
尽相同：State 模式主要是要适应对象对于状态改变时的不同处理策略的实现，而 Strategy则主要是具体算法和实现接口的解耦。
State 模式很好地实现了对象的状态逻辑和动作实现的分离，状态逻辑分布在 State 的派生类中实现，而动作实现则可以放在 Context 类中实现（这也是为什么 State 派生类需要拥有一个指向 Context 的指针）。这使得两者的变化相互独立，改变 State 的状态逻辑可以很容易复用 Context 的动作，也可以在不影响 State 派生类的前提下创建 Context 的子类来更改或替换动作实现。
State 模式问题主要是逻辑分散化，状态逻辑分布到了很多的 State 的子类中，很难看到整个的状态逻辑图，降低了系统的可维护性。
本文参考《设计模式精解－GoF 23 种设计模式解析附 C++实现源码》，对内容进行整理，方便大家学习。如想学习详细内容，请参考此书。