C++ State 设计模式

C++ State 设计模式

 设计模式看的太快不利于消化，一方面是最近比较忙，另一方面是想让自己多消化消化自己所看的东西。所以本周只看了一个Sate设计模式

State模式的意图有2点：

1. 分散逻辑判断和处理。

对于State来说，无非就是状态的切换。说白了最终结果和switch/case差不多。对于少量的状态判断和逻辑处理，switch还行。但是对于一个较大的项目而且条件判断比较复杂，这个时候switch不仅效率低下，而且无法控制。State模式巧妙的将逻辑判断和处理放到状态对象中，而不是把条件判断和状态切换放在Context上下文中，从而分散了逻辑判断和处理。如果要更改逻辑，Context就不需要改动，只改动State类即可。

2. 去耦。我想这应该是Gof 设计模式的核心。

类图如下：

State模式中，将条件判断和状态切换放在State的派生类中。这样降低了Context逻辑判断的复杂和依赖，降低了耦合度。

主要实现代码：

 //Context.h #pragma once class State; class Context { friend class State; public: Context(void); ~Context(void); public: void OperationInterfaceA(); void OperationInterfaceB(); protected: void ChangeState(State *pState);//状态切换 private: State *__m_pState;//维护一个State基类指针 };

//Context.cpp #include "Context.h" #include "State.h" #include "ConcreteStateA.h" Context::Context(void) { __m_pState = ConcreteStateA::SInstance(); } Context::~Context(void) { delete __m_pState; __m_pState; } void Context::OperationInterfaceA() { __m_pState->OperationInterfaceA(this); } void Context::OperationInterfaceB() { __m_pState->OperationInterfaceB(this); } void Context::ChangeState(State *pState) { __m_pState = pState; }

//State.h #pragma once class Context; class State { public: State(void); virtual ~State(void); public: virtual void OperationInterfaceA(Context *pCxt){} virtual void OperationInterfaceB(Context *pCxt){} virtual void Handle(); virtual void ChangeState(State *pSt, Context *pCxt); };

//State.cpp #include "State.h" #include "Context.h" State::State(void) { } State::~State(void) { } void State::Handle() { } void State::ChangeState(State *pSt, Context *pCxt) { pCxt->__m_pState = pSt; }

//ConcreteStateA.h #pragma once #include "state.h" class ConcreteStateA : public State { public: static ConcreteStateA *SInstance(); ~ConcreteStateA(void); public: void Handle(); void OperationInterfaceA(Context *pCxt); private: ConcreteStateA(void); static ConcreteStateA *__m_spInstance; };

//ConcreteStateA.cpp #include <iostream> #include "ConcreteStateA.h" #include "ConcreteStateB.h" using namespace std; ConcreteStateA* ConcreteStateA::__m_spInstance =NULL; ConcreteStateA::ConcreteStateA(void) { } ConcreteStateA::~ConcreteStateA(void) { if (__m_spInstance != NULL) { delete __m_spInstance; __m_spInstance = NULL; } } ConcreteStateA* ConcreteStateA::SInstance() { if (__m_spInstance == NULL) { __m_spInstance = new ConcreteStateA(); } return __m_spInstance; } void ConcreteStateA::Handle() { cout << "Hi, I am in the StateA" << endl; } void ConcreteStateA::OperationInterfaceA(Context *pCxt) { Handle(); ChangeState(ConcreteStateB::SInstance(), pCxt);//状态切换逻辑处理 }

//ConcreteStateB.h #pragma once #include "state.h" class ConcreteStateB : public State { public: static ConcreteStateB* SInstance(); ~ConcreteStateB(void); public: void Handle(); void OperationInterfaceB(Context *pCxt); private: ConcreteStateB(void); static ConcreteStateB *__m_sInstance; };

//ConcreteStateB.cpp #include <iostream> #include "ConcreteStateB.h" #include "ConcreteStateA.h" using namespace std; ConcreteStateB* ConcreteStateB::__m_sInstance = NULL; ConcreteStateB::ConcreteStateB(void) { } ConcreteStateB::~ConcreteStateB(void) { if (__m_sInstance != NULL) { delete __m_sInstance; __m_sInstance = NULL; } } ConcreteStateB* ConcreteStateB::SInstance() { if (__m_sInstance == NULL) { __m_sInstance = new ConcreteStateB(); } return __m_sInstance; } void ConcreteStateB::Handle() { cout << "Hi, I am in the StateB" << endl; } void ConcreteStateB::OperationInterfaceB(Context *pCxt) { Handle(); State::ChangeState(ConcreteStateA::SInstance(), pCxt); }

//main.cpp #include <iostream> #include "Context.h" #include "ConcreteStateA.h" #include "ConcreteStateB.h" using namespace std; int main(void) { Context txt; txt.OperationInterfaceA(); txt.OperationInterfaceB(); txt.OperationInterfaceA(); }

输出如下：

Hi, I am in the StateA

Hi, I am in the StateB

Hi, I am in the StateA