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