状态模式

一 应用场景
一个机器有，一个排气状态，一个是压缩状态。在运行时，不同的状态会有不同的行为，当前的状态机在适当的时候会过渡到下一状态。

二 定义
状态模式State Pattern：允许一个对象在其内部状态改变时改变它的行为，对象看起来似乎修改了它的类。其别名为状态对象(Objects for States)，状态模式是一种对象行为型模式。

Context 环境类：环境类又称为上下文类，它是拥有多种状态的对象。由于环境类的状态存在多样性且在不同状态下对象的行为有所不同，因此将状态独立出去形成单独的状态类。在环境类中维护一个抽象状态类State的实例，这个实例定义当前状态，在具体实现时，它是一个State子类的对象。

State 抽象状态类：它用于定义一个接口以封装与环境类的一个特定状态相关的行为，在抽象状态类中声明了各种不同状态对应的方法，而在其子类中实现类这些方法，由于不同状态下对象的行为可能不同，因此在不同子类中方法的实现可能存在不同，相同的方法可以写在抽象状态类中。

ConcreteState（具体状态类）：它是抽象状态类的子类，每一个子类实现一个与环境类的一个状态相关的行为，每一个具体状态类对应环境的一个具体状态，不同的具体状态类其行为有所不同。

三 C++实现
Machine.h

#pragma once

class Machine;

class State
{
public:
    State(){}

    virtual ~State(){}

    virtual void Operate(Machine * _mac){}
};

class Machine{
public:
    Machine(State * _state):m_state(_state),m_step(0){}

    virtual ~Machine(){}

    int getStep(){
        return m_step;
    }

    void setStep(int _step){
        m_step = _step;
    }

    void setState(State * _state){
        m_state = _state;
    }

    void mOperate(){
        m_state->Operate(this);
    }

private:
    State * m_state;
    int m_step;
};

States.h

#pragma once 

#include 
#include 

using namespace std;

#include "Machine.h"


class ExhaustState:public State
{
public:
    ExhaustState(){}

    virtual ~ExhaustState(){}

    void Operate(Machine * _mac){
        if(_mac->getStep()==2){
            std::cout << "step:" << _mac->getStep() << "exhaust state" << std::endl;
        }
    }

};

class CompressState:public State
{
public:
    CompressState(){}

    virtual ~CompressState(){}

    void Operate(Machine * _mac){
        if(_mac->getStep() == 1){
            std::cout << "step:" << _mac->getStep() << "compress state\n" << std::endl;
        }else{
            _mac->setState(new ExhaustState());
            _mac->mOperate();
        }
    }
};

main.cpp

#include 

#include "Machine.h"
#include "States.h"

using namespace std;


int main()
{
    State * c_state = new CompressState();
    Machine * mac = new Machine(c_state);

    for(int i=1;i<3;i++){
        mac->setStep(i);
        mac->mOperate();
    }


    delete c_state;
    c_state = NULL;
    delete mac;
    mac = NULL;

    system("pause");
    return 0;
}

运行结果：

四总结
优点
1 封装了状态的转换规则，在状态模式中可以将状态的转换代码封装在环境类或者具体状态类中，可以对状态转换代码进行集中管理，而不是分散在一个个业务方法中。
2 将所有与某个状态有关的行为放到一个类中，只需要注入一个不同的状态对象即可使环境对象拥有不同的行为。
3 允许状态转换逻辑与状态对象合成一体，而不是提供一个巨大的条件语句块，状态模式可以让我们避免使用庞大的条件语句来将业务方法和状态转换代码交织在一起。
4 可以让多个环境对象共享一个状态对象，从而减少系统中对象的个数。

缺点
1 状态模式的使用必然会增加系统中类和对象的个数，导致系统运行开销增大。
2 状态模式的结构与实现都较为复杂，如果使用不当将导致程序结构和代码的混乱，增加系统设计的难度。
3 状态模式对“开闭原则”的支持并不太好，增加新的状态类需要修改那些负责状态转换的源代码，否则无法转换到新增状态；而且修改某个状态类的行为也需修改对应类的源代码。