C++状态模式

谁践踏了优雅 2022-09-17 05:19 2阅读 0赞

头文件：

#ifndef CSTATEMODE_H
    #define CSTATEMODE_H
    
    
    #include<QDebug>
    #include <iostream>
    #include<string>
    #include <vector>
    using namespace std;
    
    #define cout qDebug() << "[" << __FILE__ << ":" << __LINE__ << ":" << __func__ << "]"
    
    
    class CStateMode
    {
        
    public:
        CStateMode();
    };
    
    /*
     * 允许一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它的类。
    说明：CContext保持电梯的状态，并提供操作的接口函数。当函数被调用时，CContext直接调用当前状态的相应函数。由状态的接口函数来确定是否可以执行这个动作，以及修改状态为执行这个动作后的状态。
    
    */
    
    //电梯实体抽象类
    class ILift
    {
        
    public:
    
        ILift(void)
        {
        
        }
    
        virtual ~ILift(void)
        {
        
        }
        static const int OPENING_STATE = 1;
        static const int CLOSING_STATE = 2;
        static const int RUNNING_STATE = 3;
        static const int STOPPING_STATE = 4;
        virtual void SetState(int state) = 0;
        virtual void Open() = 0;
        virtual void Close() = 0;
        virtual void Run() = 0;
        virtual void Stop() = 0;
    };
    //电梯实体类
    class CLift :
        public ILift
    {
        
    public:
        CLift(void);
        ~CLift(void);
        void SetState(int state);
        void Open();
        void Close();
        void Run();
        void Stop();
    private:
        int m_state;
        void OpenWithoutLogic();
        void CloseWithoutLogic();
        void RunWithoutLogic();
        void StopWithoutLogic();
    };
    
    //电梯状态抽象类
    
    class CContext;
    class CLiftState
    {
        
    public:
        CLiftState(void);
        virtual ~CLiftState(void);
        void SetContext(CContext *pContext);
        virtual void Open() = 0;
        virtual void Close() = 0;
        virtual void Run() = 0;
        virtual void Stop() = 0;
    protected:
        CContext *m_pContext;
    };
    
    //电梯门关闭
    class CCloseingState :
        public CLiftState
    {
        
    public:
        CCloseingState(void);
        ~CCloseingState(void);
        void Open();
        void Close();
        void Run();
        void Stop();
    };
    //电梯门打开
    class COpenningState :
        public CLiftState
    {
        
    public:
        COpenningState(void);
        ~COpenningState(void);
        void Open();
        void Close();
        void Run();
        void Stop();
    };
    
    //电梯运行
    class CRunningState :
        public CLiftState
    {
        
    public:
        CRunningState(void);
        ~CRunningState(void);
        void Open();
        void Close();
        void Run();
        void Stop();
    };
    //电梯停止
    class CStoppingState :
        public CLiftState
    {
        
    public:
        CStoppingState(void);
        ~CStoppingState(void);
        void Open();
        void Close();
        void Run();
        void Stop();
    };
    
    //电梯的控制面板
    class CContext
    {
        
    public:
        CContext(void);
        ~CContext(void);
        static COpenningState *pOpenningState;
        static CCloseingState *pCloseingState;
        static CRunningState *pRunningState;
        static CStoppingState *pStoppingState;
        CLiftState * GetLiftState();
        void SetLiftState(CLiftState *pLiftState);
        void Open();
        void Close();
        void Run();
        void Stop();
    private:
        CLiftState *m_pLiftState;
    };
    
    int StateTest();
    
    #endif // CSTATEMODE_H

源文件：

#include "cstatemode.h"
    
    CStateMode::CStateMode()
    {
        
    
    }
    
    CLift::CLift(void)
    {
        
        this->m_state = 0;
    }
    
    CLift::~CLift(void)
    {
        
    }
    
    void CLift::SetState(int state)
    {
        
        this->m_state = state;
    }
    
    void CLift::Open()
    {
        
        switch(this->m_state)
        {
        
        case OPENING_STATE:
            break;
        case CLOSING_STATE:
            this->OpenWithoutLogic();
            this->SetState(OPENING_STATE);
            break;
        case RUNNING_STATE:
            break;
        case STOPPING_STATE:
            this->OpenWithoutLogic();
            this->SetState(OPENING_STATE);
            break;
        }
    }
    
    void CLift::Close()
    {
        
        switch(this->m_state)
        {
        
        case OPENING_STATE:
            this->CloseWithoutLogic();
            this->SetState(CLOSING_STATE);
            break;
        case CLOSING_STATE:
            break;
        case RUNNING_STATE:
            break;
        case STOPPING_STATE:
            break;
        }
    }
    
    void CLift::Run()
    {
        
        switch(this->m_state)
        {
        
        case OPENING_STATE:
            break;
        case CLOSING_STATE:
            this->RunWithoutLogic();
            this->SetState(RUNNING_STATE);
            break;
        case RUNNING_STATE:
            break;
        case STOPPING_STATE:
            this->RunWithoutLogic();
            this->SetState(RUNNING_STATE);
            break;
        }
    }
    
    void CLift::Stop()
    {
        
        switch(this->m_state)
        {
        
        case OPENING_STATE:
            break;
        case CLOSING_STATE:
            this->StopWithoutLogic();
            this->SetState(CLOSING_STATE);
            break;
        case RUNNING_STATE:
            this->StopWithoutLogic();
            this->SetState(CLOSING_STATE);
            break;
        case STOPPING_STATE:
            break;
        }
    }
    
    void CLift::OpenWithoutLogic()
    {
        
        cout << "电梯门开启..." << endl;
    }
    
    void CLift::CloseWithoutLogic()
    {
        
        cout << "电梯门关闭..." << endl;
    }
    
    void CLift::RunWithoutLogic()
    {
        
        cout << "电梯上下跑起来..." << endl;
    }
    
    void CLift::StopWithoutLogic()
    {
        
        cout << "电梯停止了..." << endl;
    }
    
    
    //
    CLiftState::CLiftState(void)
    {
        
    }
    
    CLiftState::~CLiftState(void)
    {
        
    }
    
    void CLiftState::SetContext( CContext *pContext )
    {
        
        m_pContext = pContext;
    }
    
    //
    CCloseingState::CCloseingState(void)
    {
        
    }
    
    CCloseingState::~CCloseingState(void)
    {
        
    }
    
    void CCloseingState::Open()
    {
        
        this->CLiftState::m_pContext->SetLiftState(CContext::pOpenningState);
        this->CLiftState::m_pContext->GetLiftState()->Open();
    }
    
    void CCloseingState::Close()
    {
        
        cout << "电梯门关闭..." << endl;
    }
    
    void CCloseingState::Run()
    {
        
        this->CLiftState::m_pContext->SetLiftState(CContext::pRunningState);
        this->CLiftState::m_pContext->GetLiftState()->Run();
    }
    
    void CCloseingState::Stop()
    {
        
        this->CLiftState::m_pContext->SetLiftState(CContext::pStoppingState);
        this->CLiftState::m_pContext->GetLiftState()->Stop();
    }
    
    //
    COpenningState::COpenningState(void)
    {
        
    }
    
    COpenningState::~COpenningState(void)
    {
        
    }
    
    void COpenningState::Open()
    {
        
        cout << "电梯门开启..." << endl;
    }
    
    void COpenningState::Close()
    {
        
        this->CLiftState::m_pContext->SetLiftState(CContext::pCloseingState);
        this->CLiftState::m_pContext->GetLiftState()->Close();
    }
    
    void COpenningState::Run()
    {
        
        //do nothing
    }
    
    void COpenningState::Stop()
    {
        
        //do nothing
    }
    
    //
    
    CRunningState::CRunningState(void)
    {
        
    }
    
    CRunningState::~CRunningState(void)
    {
        
    }
    
    void CRunningState::Open()
    {
        
        //do nothing
    }
    
    void CRunningState::Close()
    {
        
        //do nothing
    }
    
    void CRunningState::Run()
    {
        
        cout << "电梯上下跑..." << endl;
    }
    
    void CRunningState::Stop()
    {
        
        this->CLiftState::m_pContext->SetLiftState(CContext::pStoppingState);
        this->CLiftState::m_pContext->GetLiftState()->Stop();
    }
    /
    CStoppingState::CStoppingState(void)
    {
        
    }
    
    CStoppingState::~CStoppingState(void)
    {
        
    }
    
    void CStoppingState::Open()
    {
        
        this->CLiftState::m_pContext->SetLiftState(CContext::pOpenningState);
        this->CLiftState::m_pContext->GetLiftState()->Open();
    }
    
    void CStoppingState::Close()
    {
        
        //do nothing
    }
    
    void CStoppingState::Run()
    {
        
        this->CLiftState::m_pContext->SetLiftState(CContext::pRunningState);
        this->CLiftState::m_pContext->GetLiftState()->Run();
    }
    
    void CStoppingState::Stop()
    {
        
        cout << "电梯停止了..." << endl;
    }
    ///
    COpenningState* CContext::pOpenningState = NULL;
    CCloseingState* CContext::pCloseingState = NULL;
    CRunningState* CContext::pRunningState = NULL;
    CStoppingState* CContext::pStoppingState = NULL;
    
    CContext::CContext(void)
    {
        
        m_pLiftState = NULL;
        pOpenningState = new COpenningState();
        pCloseingState = new CCloseingState();
        pRunningState = new CRunningState();
        pStoppingState = new CStoppingState();
    }
    
    CContext::~CContext(void)
    {
        
        delete pOpenningState;
        pOpenningState = NULL;
        delete pCloseingState;
        pCloseingState = NULL;
        delete pRunningState;
        pRunningState = NULL;
        delete pStoppingState;
        pStoppingState = NULL;
    }
    
    CLiftState * CContext::GetLiftState()
    {
        
        return m_pLiftState;
    }
    
    void CContext::SetLiftState(CLiftState *pLiftState)
    {
        
        this->m_pLiftState = pLiftState;
        this->m_pLiftState->SetContext(this);
    }
    
    void CContext::Open()
    {
        
        this->m_pLiftState->Open();
    }
    
    void CContext::Close()
    {
        
        this->m_pLiftState->Close();
    }
    
    void CContext::Run()
    {
        
        this->m_pLiftState->Run();
    }
    
    void CContext::Stop()
    {
        
        this->m_pLiftState->Stop();
    }
    
    //
    //测试使用
    static void DoIt()
    {
        
        //ILift.h, Lift.h, Lift.cpp
        ILift *pLift = new CLift();
        pLift->SetState(ILift::STOPPING_STATE);//电梯的初始条件是停止状态。
        pLift->Open();//首先是电梯门开启，人进去
        pLift->Close();//然后电梯门关闭
        pLift->Run();//再然后，电梯跑起来，向上或者向下
        pLift->Stop();//最后到达目的地，电梯停下来
        delete pLift;
    }
    
    
    static void DoNew()
    {
        
        //LiftState.h, LiftState.cpp, OpenningState.h, CloseingState.h, RunningState.h, StoppingState.h
        //Context.h, Context.cpp
        CContext context;
        CCloseingState closeingState;
        context.SetLiftState(&closeingState);
        context.Close();
        context.Open();
        context.Run();
        context.Stop();
    }
    
    int StateTest()
    {
        
        cout << "----------使用模式之前----------" << endl;
        DoIt();
        cout << "----------使用模式之后----------" << endl;
        DoNew();
        return 0;
    }