状态模式【STATE PATTERN 】

statepattern.h

/*
 * statepattern.h
 *
 *  Created on: Sep 26, 2012
 *      Author: hl
 */

#ifndef _STATEPATTERN_H_
#define _STATEPATTERN_H_

/**
 * @brief 电梯动作接口和状态定义
 */
class ILift
{
public:
    virtual void setState(int state) = 0;
public:
    virtual void open() = 0;
    virtual void close() = 0;
    virtual void run() = 0;
    virtual void stop() = 0;
public:
    const static int OPENING_STATE = 1;    /// < 类似java的 public final static int xx = 1;
    const static int CLOSING_STATE = 2;
    const static int RUNNING_STATE = 3;
    const static int STOPPING_STATE = 4;
public:
    const static int WARNING_1 = 1;        /// < 打开状态下不能运行
    const static int WARNING_2 = 2;        /// < 运行状态下不能开门
};

/**
 * @brief 电梯类 - 利用状态的判断(switch case)来实现逻辑结构！代码多了...
 */
class Lift : public ILift
{
public:
    void setState(int state);
public:
    void open();    /// < 打开电梯
    void close();    /// < 关闭电梯
    void run();        /// < 启动电梯
    void stop();    /// < 停止电梯
private:
    void openWithoutLogic();    /// < 打开电梯
    void closeWithoutLogic();    /// < 关闭电梯
    void runWithoutLogic();        /// < 启动电梯
    void stopWithoutLogic();    /// < 停止电梯
private:
    void Waring(int errno);
private:
    int State;
};


/// < -------------真正的状态模式--------------------------


class Context;
/**
 * @brief 电梯动作接口和状态定义
 */
class LiftState
{
public:
    ~LiftState()
    {
        if (context)
            delete context;
    }
public:
    void setContext(Context * _context)
    {
        this->context = _context;
    }
public:
    virtual void open() = 0;
    virtual void close() = 0;
    virtual void run() = 0;
    virtual void stop() = 0;
protected:
    Context * context;
};

/**
 * @brief 开门状态
 */
class OpenState : public LiftState
{
public:
    void open();
    void close();
    void run();
    void stop();
};

/**
 * @brief 关闭状态 - 其他状态类似
 */
class CloseState : public LiftState
{
public:
    void open();
    void close();
    void run();
    void stop();
};

/**
 * @brief 运行环境
 */
class Context
{
public:
    ~Context()
    {
        if (liftState)
            delete liftState;
        if (openningState)
            delete openningState;
        if (closeingState)
            delete closeingState;
    }
public:
    LiftState * getLiftState() {
        return liftState;
    }
    void setLiftState(LiftState * liftState) {
        this->liftState = liftState;
        //把当前的环境通知到各个实现类中
        this->liftState->setContext(this);
    }
    void open()
    {
        this->liftState->open();
    }
    void close()
    {
        this->liftState->close();
    }
    void run()
    {
        this->liftState->run();
    }
    void stop()
    {
        this->liftState->stop();
    }
public:
    static OpenState * openningState;
    static CloseState * closeingState;
private:
    LiftState * liftState;
};

#endif /* _STATEPATTERN_H_ */

statepattern.cpp

//============================================================================
// Name        : statepattern.cpp
// Author      : hl
// Version     :
// Copyright   : Copyright (c) 2012 Tiros
// Description : State Pattern in C++, Ansi-style
//============================================================================

#include "statepattern.h"
#include <iostream>
using namespace std;

void Lift::setState(int state)
{
    State = state;
}

void Lift::open()
{
    switch(State)
    {
    case OPENING_STATE:
        break;
    case CLOSING_STATE:        /// < 如果关闭，则可以打开；同时修改状态为打开状态.
        this->openWithoutLogic();
        this->setState(OPENING_STATE);
        break;
    case RUNNING_STATE:
        Waring(WARNING_2);
        break;
    case STOPPING_STATE:        /// < 如果停止的，则可以打开；同时修改状态为打开状态.
        this->openWithoutLogic();
        this->setState(OPENING_STATE);
        break;
    default:
        break;
    }
}

void Lift::close()
{
    switch (State)
    {
    case OPENING_STATE:        /// < 如果打开的，则可以关闭；同时修改状态为关闭状态.
        this->closeWithoutLogic();
        this->setState(CLOSING_STATE);
        break;
    case CLOSING_STATE:
        break;
    case RUNNING_STATE:
        break;
    case STOPPING_STATE:
        break;
    default:
        break;
    }
}

void Lift::run()
{
    switch (State)
    {
    case OPENING_STATE:
        Waring(WARNING_1);
        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;
    default:
        break;
    }
}

void Lift::stop()
{
    switch (State)
    {
    case OPENING_STATE:
        break;
    case CLOSING_STATE:        /// <  如果关闭，则可以停止；同时修改状态为停止状态.
        this->stopWithoutLogic();
        this->setState(STOPPING_STATE);
        break;
    case RUNNING_STATE:        /// <  如果运行，则可以停止；同时修改状态为停止状态.
        this->stopWithoutLogic();
        this->setState(STOPPING_STATE);
        break;
    case STOPPING_STATE:
        break;
    default:
        break;
    }
}

void Lift::openWithoutLogic()
{
    cout << "打开门" << endl;
}

void Lift::closeWithoutLogic()
{
    cout << "关门" << endl;
}

void Lift::runWithoutLogic()
{
    cout << "运行" << endl;
}

void Lift::stopWithoutLogic()
{
    cout << "停止" << endl;
}

void Lift::Waring(int errno)
{
    switch(errno)
    {
    case WARNING_1:
        cout << "打开状态下不能运行" << endl;
        break;
    case WARNING_2:
        cout << "运行状态下不能开门" << endl;
        break;
    default:
        break;
    }
}


/// < --------------------------------------

OpenState * Context::openningState = new OpenState();
CloseState * Context::closeingState = new CloseState();

/**
 * @brief 开门状态 - 可以关闭
 */
void OpenState::open()
{
    cout << "电梯门开启..." << endl;
}

void OpenState::close()
{
    context->setLiftState(context->closeingState);
    context->getLiftState()->close();
}

void OpenState::run()
{

}

void OpenState::stop()
{

}

/**
 * @brief 关闭状态 - 可以打开
 */
void CloseState::open()
{
    context->setLiftState(context->openningState);    /// < 设置当前电梯状态为openning状态
    context->getLiftState()->open();                /// < OpenState's liftState打开
}

void CloseState::close()
{
    cout << "电梯门关闭..." << endl;
}

void CloseState::run()    /// < 设置为运行状态；
{

}

void CloseState::stop()    /// < 设置为运行状态；
{

}





int main()
{
    ILift * lif = new Lift();
    lif->setState(ILift::CLOSING_STATE);    /// < 初始为关闭状态

    lif->open();
    lif->run();     /// < Warning1
    lif->close();
    lif->run();
    lif->open();    /// < Warning2
    lif->stop();
    /*
    打开门
    打开状态下不能运行
    关门
    运行
    运行状态下不能开门
    停止
    */

    cout << "---------真正的状态模式-------------------\n";
    Context cont;
    cont.setLiftState(new CloseState());

    cont.close();
    cont.open();
    cont.close();

    return 0;
}