C++設計模式-State狀態模式

State狀態模式
作用：當一個對象的內在狀態改變時允許改變其行為，這個對象看起來像是改變了其類。

UML圖如下：

State類，抽象狀態類，定義一個接口以封裝與Context的一個特定狀態相關的行為。
ConcreteState類，具體狀態，每一個子類實現一個與Context的一個狀態相關的行為。
Context類，維護一個ConcreteState子類的實例，這個實例定義當前的狀態。

狀態模式主要解決的是當控制一個對象狀態轉換的條件表達式過於復雜時的情況。把狀態的判斷邏輯轉移到表示不同狀態的一系列類當中，可以把復雜的判斷邏輯簡化。

狀態模式的好處是將與特定狀態相關的行為局部化，並且將不同狀態的行為分割開來。

將特定的狀態相關的行為都放入一個對象中，由於所有與狀態相關的代碼都存在於某個ConcreteState中，所以通過定義新的子類可以很容易地增加新的狀態和轉換。

可以消除龐大的條件分支語句。狀態模式通過把各種狀態轉移邏輯分布到State的子類之間，來減少相互間的依賴。

當一個對象的行為取決於它的狀態，並且它必須在運行時刻根據狀態改變它的行為時，就可以考慮使用狀態模式。
另外如果業務需求某項業務有多個狀態，通常都是一些枚舉常量，狀態的變化都是依靠大量的多分支判斷語句來實現，此時應該考慮將每一種業務狀態定義為一個State的子類。這樣這些對象就可以不依賴於其他對象兒獨立變化了。

代碼如下：

State.h

#ifndef _STATE_H_
#define _STATE_H_

class Context;
class State
{
public:
    virtual void Handle(Context* pContext)=0;
    ~State();
protected:
    State();
private:
};

class ConcreteStateA : public State
{
public:
    ConcreteStateA();
    ~ConcreteStateA();
    virtual void Handle(Context* pContext);
protected:
private:
};

class ConcreteStateB : public State
{
public:
    ConcreteStateB();
    ~ConcreteStateB();
    virtual void Handle(Context* pContext);
protected:
private:
};

class ConcreteStateC : public State
{
public:
    ConcreteStateC();
    ~ConcreteStateC();
    virtual void Handle(Context* pContext);
protected:
private:
};

class Context
{
public:
    Context(State* pState);
    ~Context();
    void Request();
    void ChangeState(State* pState);
protected:
private:
    State* _state;
};

#endif

State.cpp

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

using namespace std;

State::State()
{}

State::~State()
{}

ConcreteStateA::ConcreteStateA()
{}

ConcreteStateA::~ConcreteStateA()
{}

//執行該狀態的行為並改變狀態
void ConcreteStateA::Handle(Context* pContext)
{
    cout << "ConcreteStateA" << endl;
    pContext->ChangeState(new ConcreteStateB());
}

ConcreteStateB::ConcreteStateB()
{}

ConcreteStateB::~ConcreteStateB()
{}

//執行該狀態的行為並改變狀態
void ConcreteStateB::Handle(Context* pContext)
{
    cout << "ConcreteStateB" << endl;
    pContext->ChangeState(new ConcreteStateC());
}

ConcreteStateC::ConcreteStateC()
{}

ConcreteStateC::~ConcreteStateC()
{}

//執行該狀態的行為並改變狀態
void ConcreteStateC::Handle(Context* pContext)
{
    cout << "ConcreteStateC" << endl;
    pContext->ChangeState(new ConcreteStateA());
}

//定義_state的初始狀態
Context::Context(State* pState)
{
    this->_state = pState;
}

Context::~Context()
{}

//對請求做處理，並設置下一狀態
void Context::Request()
{
    if(NULL != this->_state)
    {
        this->_state->Handle(this);
    }
}

//改變狀態
void Context::ChangeState(State* pState)
{
    this->_state = pState;
}

main.cpp

#include "State.h"

int main()
{
    State* pState = new ConcreteStateA();
    Context* pContext = new Context(pState);
    pContext->Request();
    pContext->Request();
    pContext->Request();
    pContext->Request();
    pContext->Request();
    return 0;
}