状态设计模式笔记

状态模式（State），当一个对象的内在状态改变时，允许改变其行为，这个对象看起来像是改变了其类【DP】

状态模式主要解决的是，当控制一个对象状态转换的条件表达式过于复杂时的情况。把状态的判断逻辑转移到表示不同状态的一系列类当中，可以把复杂的判断逻辑简化。

当然如果这个状态判断很简单，那就没有必要用‘状态模式’了。

 

我的实现源代码：

state.h

#ifndef STATE_H
#define STATE_H

class Context;
//my code
class State
{
public:
    virtual void Handle(Context *pContext) = 0;
};

class Context
{
public:
    Context(State *pState);
    ~Context();
    void Request();
    void SetState(State *pState);

private:
    State *m_State;
};

class ConcreteA : public State
{
public:
    virtual void Handle(Context *pContext);
};

class ConcreteB : public State
{
public:
    virtual void Handle(Context *pContext);
};

#endif // STATE_H

state.cpp:

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

using namespace std;

Context::Context(State *pState)
{
    this->m_State = pState;
}

Context::~Context()
{

}

void Context::SetState(State *pState)
{
    if(pState != NULL)
        this->m_State = pState;
}

void Context::Request()
{
    this->m_State->Handle(this);
}

void ConcreteA::Handle(Context *pContext)
{
    cout<<"this is concrete A"<<endl;
    pContext->SetState(new ConcreteB());
}

void ConcreteB::Handle(Context *pContext)
{
    cout<<"this is concrete B"<<endl;
    pContext->SetState(new ConcreteA());
}

main.cpp

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

using namespace std;

int main()
{
    State *pState = new ConcreteA();
    Context *c = new Context(pState);

    c->Request();
    c->Request();
    c->Request();
    c->Request();
    return 0;
}

状态模式好处与用处

“状态模式的好处是将与特定状态相关的行为局部化，并且将不同状态的行为分割开来【DP】。”

“将特定的状态相关的行为都放入一个对象中，由于所有与状态相关的代码都存在于某个ConcreteState中，所以通过定义新的子类可以很容易地增加新的状态和转换【DP】。”

主要的目的是：消除庞大的条件分支语句，状态模式通过把各种状态转移逻辑分布到State的子类之间，来减少相互间的依赖，好比把整个版面改成一个又一个的活字，此时就容易维护和扩展了。

当一个对象的行为取决与它的状态，并且他必须在运行时刻根据状态改变它的行为时，就可以考虑状态模式了。

工作状态-状态模式版（c++）

workstate.h

#ifndef WORKSTATE_H
#define WORKSTATE_H

class Work;

class WorkState
{
public:
    virtual void WriteProgram(Work *pWork) = 0;
    WorkState();
};

class Work
{
public:
    Work(WorkState *pWorkState);
    void ChangeWorkState(WorkState *pWorkState);
    int GetWorkHour();
    void ChangeWorkHour(int hour);
    void ChangeWorkFinishFlag(bool flag);
    bool GetWorkFinishFlag();
    void Writing();

private:
    WorkState *m_WorkState;
    int m_Hour;
    bool m_Finishflag;
};

class WorkMorning : public WorkState
{
public:
    virtual void WriteProgram(Work *pWork);
};

class WorkNoon : public WorkState
{
public:
    virtual void WriteProgram(Work *pWork);
};

class WorkAfternoon : public WorkState
{
public:
    virtual void WriteProgram(Work *pWork);
};

class WorkNight : public WorkState
{
public:
    virtual void WriteProgram(Work *pWork);
};

class WorkOff : public WorkState
{
public:
    virtual void WriteProgram(Work *pWork);
};

class WorkSleep : public WorkState
{
public:
    virtual void WriteProgram(Work *pWork);
};

#endif // WORKSTATE_H

workstate.cpp

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

using namespace std;

WorkState::WorkState()
{

}

Work::Work(WorkState *pWorkState)
{
    this->m_WorkState = pWorkState;
    this->m_Hour = 0;
    this->m_Finishflag = false;
}

void Work::ChangeWorkState(WorkState *pWorkState)
{
    this->m_WorkState = pWorkState;
}

int Work::GetWorkHour()
{
    return m_Hour;
}

void Work::ChangeWorkHour(int hour)
{
    this->m_Hour = hour;
}

void Work::ChangeWorkFinishFlag(bool flag)
{
    this->m_Finishflag = flag;
}

bool Work::GetWorkFinishFlag()
{
    return m_Finishflag;
}

void Work::Writing()
{
    this->m_WorkState->WriteProgram(this);
}

void WorkMorning::WriteProgram(Work *pWork)
{
    if(pWork->GetWorkHour() < 12)
        cout<<"WorkMorning: Work very good."<<endl;
    else{
//        cout<<"WorkMorning: change to Noon"<<endl;
        pWork->ChangeWorkState(new WorkNoon());
        pWork->Writing();                       //切换后运行
    }
}

void WorkNoon::WriteProgram(Work *pWork)
{
    if(pWork->GetWorkHour() < 13)
        cout<<"WorkNoon: hungry, lunch: sleeping"<<endl;
    else {
        pWork->ChangeWorkState(new WorkAfternoon());
        pWork->Writing();
    }
}

void WorkAfternoon::WriteProgram(Work *pWork)
{
    if(pWork->GetWorkHour() < 17)
            cout<<"WorkAfternoon: Work very good"<<endl;
    else {
        pWork->ChangeWorkState(new WorkNight());
        pWork->Writing();
    }
}

void WorkNight::WriteProgram(Work *pWork)
{
    if(pWork->GetWorkFinishFlag()) {
        pWork->ChangeWorkState(new WorkOff());
        pWork->Writing();
    }
    else {
        if(pWork->GetWorkHour() < 21)
            cout<<"WorkNight: Work very tired"<<endl;
        else {
            pWork->ChangeWorkState(new WorkSleep());
            pWork->Writing();
        }
    }
}

void WorkOff::WriteProgram(Work *pWork)
{
    cout<<"WorkOff: happy"<<endl;
}

void WorkSleep::WriteProgram(Work *pWork)
{
    cout<<"WorkSleep: Can't Work"<<endl;
}

main.cpp

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

using namespace std;

int main()
{
    WorkState *pState = new WorkMorning();
    Work *pWork = new Work(pState);

    pWork->ChangeWorkHour(9);
    pWork->Writing();
    pWork->ChangeWorkHour(10);
    pWork->Writing();
    pWork->ChangeWorkHour(12);
    pWork->Writing();
    pWork->ChangeWorkHour(13);
    pWork->Writing();
    pWork->ChangeWorkHour(14);
    pWork->Writing();
    pWork->ChangeWorkHour(17);

    pWork->ChangeWorkFinishFlag(false);
//    pWork->ChangeWorkFinishFlag(true);
    pWork->Writing();

    pWork->ChangeWorkHour(19);
    pWork->Writing();
    pWork->ChangeWorkHour(22);
    pWork->Writing();

    return 0;
}