状态模式 State -- 学习HeadFirst设计模式记录

 

状态模式：允许对象在内部状态改变时改变它的行为，对象看起来好像修改了它的类。

 

面向过程方法：针对动作，在处理时switch/if-else各个状态，然后分别处理：

#include <iostream>

class GumballMachine
{
public:
    GumballMachine()
    {
        _count =  100;
        _state = NO_QUARTER;
    }

     /* 执行一个动作时，switch/if-else处理所有的状态 */
     void InsertQuarter()
    {
         switch (_state)
        {
         case SOLD_OUT:
            std::cout<< " You can't insert a quarter, the machine has sold out. "<<std::endl;
             break;

         case NO_QUARTER:
            std::cout<< " 接受投币 "<<std::endl;
            std::cout<< " You inserted a quarter. "<<std::endl;
             break;

         case HAS_QUARTER:
            std::cout<< " You can't insert another quarter. "<<std::endl;
             break;

         case SOLD:
            std::cout<< " Please wait, we're already giving you a gumball "<<std::endl;
             break;

         default:
             break;
        }
    }

     void EjectQuarter() {}
     void TurnCrank() {}
     void Dispense() {}

private:
     enum MACHINE_STATE
    {
        SOLD_OUT =  0,
        NO_QUARTER,
        HAS_QUARTER,
        SOLD,
    } ;

    MACHINE_STATE _state;
     int _count;
};

int main()
{
    std::cout<< " State Patten. "<<std::endl;

    GumballMachine gumballMachine;
    gumballMachine.InsertQuarter();

     return  0;
}

 

面向对象方法：使用状态模式，将各个状态封装为类，每个类支持所有动作。使用时，将动作委托给状态类处理。

 .h

/* 状态模式的状态接口 */
class State
{
public:
     virtual  void InsertQuarter() =  0;
     virtual  void EjectQuarter() =  0;
     virtual  void TurnCrank() =  0;  //  转动曲柄
     virtual  void Dispense() =  0;   //  分发
};

class GumballMachine
{
public:
    GumballMachine();
    
     void InsertQuarter();
    
     void SetState(State *state);
    State *GetNoQuarterState();
    State *GetHasQuarterState();
    
private:
    State *_noQuarterState;
    State *_hasQuarterState;
    
    State *_state;
     int _count;
};

 

 .c

#include <iostream>
#include  " main.h "
/*各个状态类*/
class NoQuarterState : public State
{
public:
    NoQuarterState(GumballMachine *pMachine) : _pGumballMachine(pMachine)
    {}

     virtual  void InsertQuarter()
    {
        std::cout<< " 接受投币 "<<std::endl;
        std::cout<< " You inserted a quarter. "<<std::endl;
         //   切换状态
        _pGumballMachine->SetState(_pGumballMachine->GetHasQuarterState());
    }
     virtual  void EjectQuarter()
    {
        std::cout<< " Invalid Action. "<<std::endl;
    }
     virtual  void TurnCrank()
    {
        std::cout<< " Invalid Action. "<<std::endl;
    }
     virtual  void Dispense()
    {
        std::cout<< " Invalid Action. "<<std::endl;
    }
private:
    GumballMachine *_pGumballMachine;
};

class QuarterState : public State
{
public:
    QuarterState(GumballMachine *pMachine) : _pGumballMachine(pMachine)
    {}

     virtual  void InsertQuarter()
    {
        std::cout<< " Invalid Action. "<<std::endl;
    }
     virtual  void EjectQuarter()
    {
        std::cout<< " Quarter Returned. "<<std::endl;
         //   切换状态
        _pGumballMachine->SetState(_pGumballMachine->GetNoQuarterState());
    }
     virtual  void TurnCrank()
    {
        std::cout<< " Crank Truned. "<<std::endl;
         //   切换状态 ...
        _pGumballMachine->SetState(_pGumballMachine->GetNoQuarterState());
    }
     virtual  void Dispense()
    {
        std::cout<< " Invalid Action. "<<std::endl;
    }

private:
    GumballMachine *_pGumballMachine;
};
// class SoldState : public State
// class SoldOutState : public State


GumballMachine::GumballMachine()
{
    _noQuarterState  =  new NoQuarterState( this);
    _hasQuarterState =  new QuarterState( this);
    _count =  100;
    _state = _noQuarterState;
}
/* 执行一个动作时，委托给状态类处理 */
void GumballMachine::InsertQuarter()
{
    _state->InsertQuarter();
}
void GumballMachine::SetState(State *state)
{
    _state = state;
}
State *GumballMachine::GetNoQuarterState()
{
     return _noQuarterState;
}
State *GumballMachine::GetHasQuarterState()
{
     return _hasQuarterState;
}


int main()
{
    std::cout<< " State Patten. "<<std::endl;
    
    GumballMachine gumballMachine;
    gumballMachine.InsertQuarter();
    
     return  0;
}