设计模式 -- 状态模式(State)

理解

• 状态模式一般运用在一个对象在某些条件下能触发一些不同的行为的情形。其实系统开发中到处都充斥着这些情形，初学者往往都是习惯性的用面向过程的思维方式解决问题，往往看到模块中if .. else .. 嵌套很多时，就要想想这些设计是否合理了。这种以条件判断来维护对象状态的设计至少会带来以下两个问题：
  1、当状态数目不是很多的时候，Switch/Case可能可以搞定。但是当状态数目很多的时候（实际系统中也正是如此），维护一大组的Switch/Case语句将是一件异常困难并且容易出错的事情。
  2、状态逻辑和动作实现没有分离。在很多的系统实现中，动作的实现代码直接写在状态的逻辑当中。这带来的后果就是系统的扩展性和维护得不到保证。

• 状态模式就很好的解决了上面的两个问题，它把状态逻辑和具体表现分开，一个实际的运用场景：我们的MMO游戏设计，整个游戏由一个状态机管理类控制(update)，不同的状态调用外部对应的表现。
  大体流程：

Created with Raphaël 2.1.0 开始游戏 改变状态(遥感,按技能等) 状态机(update) 角色表现 yes no

简单实例代码

• 状态模式结构图：
  

• 完整源码

• State类

//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_

---

//State.cpp
#include "stdafx.h"
#include "State.h"
#include "Context.h"
#include 
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());
}

---

• Context类

//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_

---

//context.cpp
#include "stdafx.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)
{
    this->_state = state;
    return true;
}

void Context::OperationChangState()
{
    _state->OperationChangeState(this);
}

---

• main

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