012 --- 第16章 状态模式

简述：

　　状态模式：当一个对象的内在状态改变时允许改变其行为，这个对象看起来像是改变了其类。

　　状态模式包括：抽象状态类、具体状态类、具体状态维护类

　　　　抽象状态类：定义一个接口以封装与具体状态维护类的一个特定状态相关的行为。

　　　　具体状态类：每一个子类实现一个与具体状态维护类的一个状态相关的行为。

状态模式代码：

#include <iostream>
using namespace std;

class CContext;
// 抽象状态类
class CState
{
public:
    string m_szName;
    CState() : m_szName("") {}
    virtual void Handle(CContext* pContext) = 0;
};

// 具体状态维护类
class CContext
{
private:
    CState* m_pState;

public:
    CContext(CState* pState) { m_pState = pState; }

    void SetState(CState* pState) 
    { 
        m_pState = pState; 
        cout << "当前的状态：" << m_pState->m_szName << endl;
    }
    CState* GetState() { return m_pState; }

    void Request(){ m_pState->Handle(this); }
};

// 具体状态类
class CConcreteStateA : public CState
{
public:
    CState* m_pConcreteStateB;
    
public:
    CConcreteStateA() 
    {
        m_szName = "A";
        m_pConcreteStateB = NULL;
    }

    virtual void Handle(CContext* pContext)
    {
        pContext->SetState(m_pConcreteStateB);
    }
};

// 具体状态类
class CConcreteStateB : public CState
{
public:
    CState* m_pConcreteStateA;

public:
    CConcreteStateB()
    {
        m_pConcreteStateA = NULL;
        m_szName = "B";
    }

    virtual void Handle(CContext* pContext)
    {
        pContext->SetState(m_pConcreteStateA);
    }
};

int main()
{
    CConcreteStateA ConcreteStateA;
    CConcreteStateB ConcreteStateB;
    ConcreteStateA.m_pConcreteStateB = &ConcreteStateB;
    ConcreteStateB.m_pConcreteStateA = &ConcreteStateA;
    CContext Context(&ConcreteStateA);
    Context.Request();
    Context.Request();
    Context.Request();
    Context.Request();
    system("pause");
    return 0;
}

运行结果：

例：不同时间点工作状态

代码如下：

#include <iostream>
using namespace std;

class CWork;
// 抽象状态类
class CState
{
public:
    virtual  void WriteProgram(CWork* pWork) = 0;
};

// 工作类(具体状态维护类)
class CWork
{
private:
    CState* m_pCurrentState;
    int m_nHour;
    bool m_bFinished;

public:
    CWork(CState* pState) : m_nHour(0), m_bFinished(false)
    {
        m_pCurrentState = pState;
    }

    void SetTime(int nHour)
    {
        m_nHour = nHour;
    }

    int GetTime()
    {
        return m_nHour;
    }

    void SetState(CState* pState)
    {
        m_pCurrentState = pState;
    }

    void SetTaskFinished(bool bFinished)
    {
        m_bFinished = bFinished;
    }

    bool GetTaskFinished()
    {
        return m_bFinished;
    }

    void WriteProgram()
    {
        m_pCurrentState->WriteProgram(this);
    }
};

// 具体状态类
class CForenoonState : public CState
{
public:
    CState* m_pNoonState;
public:
    virtual void WriteProgram(CWork* pWork)
    {
        if (pWork->GetTime() < 12)
            cout << "当前时间[" << pWork->GetTime() << "]点，上午工作，精神百倍。" << endl;
        else
        {
            pWork->SetState(m_pNoonState);
            pWork->WriteProgram();
        }
    }
};

// 具体状态类
class CNoonState : public CState
{
public:
    CState* m_pAfterNoonState;
public:
    virtual void WriteProgram(CWork* pWork)
    {
        if (pWork->GetTime() < 13)
            cout << "当前时间[" << pWork->GetTime() << "]点，午饭，犯困，午休。" << endl;
        else
        {
            pWork->SetState(m_pAfterNoonState);
            pWork->WriteProgram();
        }
    }
};

// 具体状态类
class CAfterNoonState : public CState
{
public:
    CState* m_pEveningState;
public:
    virtual void WriteProgram(CWork* pWork)
    {
        if (pWork->GetTime() < 17)
            cout << "当前时间[" << pWork->GetTime() << "]点，下午状态还不错，继续努力。" << endl;
        else
        {
            pWork->SetState(m_pEveningState);
            pWork->WriteProgram();
        }
    }
};

// 具体状态类
class CEveningState : public CState
{
public:
    CState* m_pSleepingState;
    CState* m_pRestState;
public:
    virtual void WriteProgram(CWork* pWork)
    {
        if (pWork->GetTaskFinished())
        {
            pWork->SetState(m_pRestState);
            pWork->WriteProgram();
        }
        else
        {
            if (pWork->GetTime() < 21)
                cout << "当前时间[" << pWork->GetTime() << "]点，加班哦，疲惫之极。" << endl;
            else
            {
                pWork->SetState(m_pSleepingState);
                pWork->WriteProgram();
            }
        }
    }
};

// 具体状态类
class CSleepingState : public CState
{
public:
    virtual void WriteProgram(CWork* pWork)
    {
        cout << "当前时间[" << pWork->GetTime() << "]点，不行了，睡着了。" << endl;
    }
};

// 具体状态类
class CRestState : public CState
{
public:
    virtual void WriteProgram(CWork* pWork)
    {
        cout << "当前时间[" << pWork->GetTime() << "]点，下班回家了。" << endl;
    }
};

int main()
{
    // C++的相互包含很微妙，不能像C#使用那么随意，可以用基类的指针实现，所以代码看起来比较冗余，也是我比较懒，没有对状态转换对象进行深入的处理。
    // 同时我为了避免使用堆区变量，都用了栈区变量传指针的方式。
    CForenoonState ForenoonState;
    CNoonState NoonState;
    CAfterNoonState AfterNoonState;
    CEveningState EveningState;
    CSleepingState SleepingState;
    CRestState RestState;
    ForenoonState.m_pNoonState = &NoonState;
    NoonState.m_pAfterNoonState = &AfterNoonState;
    AfterNoonState.m_pEveningState = &EveningState;
    EveningState.m_pSleepingState = &SleepingState;
    EveningState.m_pRestState = &RestState;

    CWork emergencyProjects(&ForenoonState);
    emergencyProjects.SetTime(9);
    emergencyProjects.WriteProgram();
    emergencyProjects.SetTime(10);
    emergencyProjects.WriteProgram();
    emergencyProjects.SetTime(12);
    emergencyProjects.WriteProgram();
    emergencyProjects.SetTime(13);
    emergencyProjects.WriteProgram();
    emergencyProjects.SetTime(14);
    emergencyProjects.WriteProgram();
    emergencyProjects.SetTime(17);
    //emergencyProjects.SetTaskFinished(true);
    emergencyProjects.SetTaskFinished(false);
    emergencyProjects.WriteProgram();
    emergencyProjects.SetTime(19);
    emergencyProjects.WriteProgram();
    emergencyProjects.SetTime(22);
    emergencyProjects.WriteProgram();
    system("pause");
    return 0;
}

输出结果：