状态模式的c++实现

Element

State

StateSet，一组state

Console，管理一组Element

代码有功能瑕疵。未实现activated元素间的互斥。

View Code
#include <iostream>
#include <vector>
#include <string>
#include <map>

inline void line(std::string str)
{
    std::cout << str << std::endl;
    return; 
}


enum StateID
{
    WAITE,
    READY,
    ACTIVATED,
    MOVING,
    ZOOMING    
};

std::string getStateName( StateID id )
{
    switch (id)
    {
    case WAITE:
        return "WAITE";
    case READY:
        return "READY";
    case ACTIVATED:
        return "ACTIVATED";
    case MOVING:
        return "MOVING";
    case ZOOMING:
        return "ZOOMING";

    }
}

class State
{
public:
    State(){}
    virtual ~State(){};

    virtual void onTouchDown( void ) = 0;
    virtual void onTouchMove( void ) = 0;
    virtual void onTouchUp( void ) = 0;
};

class StateSet
{
public:
    StateSet( void ){ line("class StateSet");}
    virtual ~StateSet( void )
    {
        if (_waitState)
        {
            delete _waitState;
        }
        if (_readyState)
        {
            delete _readyState;
        }
        if (_activatedState)
        {
            delete _activatedState;
        }
        if (_movingState)
        {
            delete _movingState;
        }
        if (_zoomingState)
        {
            delete _zoomingState;
        }
        line("class ~StateSet");
    }

    void setState(StateID id, State* state)
    {
        switch (id)
        {
        case WAITE:
            _waitState = state;
        case READY:
            _readyState = state;
        case ACTIVATED:
            _activatedState = state;
        case MOVING:
            _movingState = state;
        case ZOOMING:
            _zoomingState = state;
        }
    }

    State* getState(StateID id)
    {
        switch (id)
        {
        case WAITE:
            return _waitState;
        case READY:
            return _readyState;
        case ACTIVATED:
            return _activatedState;
        case MOVING:
            return _movingState;
        case ZOOMING:
            return _zoomingState;
        }
    }

protected:
    State * _waitState;
    State * _readyState;
    State * _activatedState;
    State * _movingState;
    State * _zoomingState;
};


enum EventID
{
    DOWN,
    MOVE,
    UP
};
EventID getEventID( std::string name)
{
    if (name == "down")
    {
        return DOWN;
    }
    else if (name == "move")
    {
        return MOVE;
    }
    else if (name == "up")
    {
        return UP;
    }

}


class WaitState;
class ReadyState;
class ActivatedState;
class MovingState;
class ZoomingState;

class Console;

class Element
{
public:
    Element( void ){}
    explicit Element( std::string name ,Console * console):
                        _name(name),
                        _console(console)
    {
        line( "class Element");
        _stateid = READY;
        _stateSet = new StateSet();
        _touchNum = 0;
        print();
    }
    virtual ~Element( void )
    {
        delete _stateSet;
        line( "class ~Element");
    }

    void run(EventID e)
    {
        switch (e)
        {
        case DOWN:
            onTouchDown();
            break;
        case MOVE:
            onTouchMove();
            break;
        case UP:
            onTouchUp();
            break;
        }
    }
    void print( void )
    {
        std::cout << "---  element  ---" << std::endl;
        std::cout << _name << ", " << getStateName(_stateid) << ", " << _touchNum << std::endl;
        std::cout << "-----------------" << std::endl;
        return;
    }
    
    void onTouchDown( void ) 
    {
        _stateSet->getState(_stateid)->onTouchDown();
        _touchNum ++;
    }
    void onTouchMove( void )
    {
        _stateSet->getState(_stateid)->onTouchMove();
    }
    void onTouchUp( void )
    {
        _stateSet->getState(_stateid)->onTouchUp();
        _touchNum --;
    }

    void ready( void )
    {
        return;
    }
    void activate( void )
    {
        return;
    }
    void deactivate( void )
    {
        return;
    }
    void move( void )
    {
        return;
    }
    void moved( void )
    {
        return;
    }
    void zoom( void )
    {
        return;
    }
    void zoomed( void )
    {
        return;
    }


public:
    std::string        _name;
    StateID            _stateid;
    StateSet *        _stateSet;
    unsigned int    _touchNum;
    Console *        _console;
};



class WaitState: public State
{
public:
    WaitState( void ){ }
    explicit WaitState( Element * element): _element(element){line("class Wait"); }
    virtual ~WaitState(){line("class ~Wait "); }

    virtual void onTouchDown( void )
    {
        _element->ready();
        _element->activate();
        _element->_stateid = ACTIVATED;
        return;
    }
    virtual void onTouchMove( void ) 
    {
        return;
    }
    virtual void onTouchUp( void )
    {
        return;
    }
protected:
    Element * _element;
};


class ReadyState: public State
{
public:
    ReadyState( void ){}
    explicit ReadyState( Element * element): _element(element){line("class Ready"); }
    virtual ~ReadyState( void ){line("class ~Ready"); }

    virtual void onTouchDown( void )
    {
        _element->activate();
        _element->_stateid = ACTIVATED;
        return;
    }
    virtual void onTouchMove( void ) 
    {
        return;
    }
    virtual void onTouchUp( void )
    {
        return;
    }
protected:
    Element * _element;
};

class ActivatedState: public State
{
public:
    ActivatedState( void ){}
    explicit ActivatedState( Element * element): _element(element){line("class Activated"); }
    virtual ~ActivatedState( void ){line("class ~Activated"); }

    virtual void onTouchDown( void )
    {
        return;
    }
    virtual void onTouchMove( void ) 
    {
        switch (_element->_touchNum )
        {
        default:
        case 2:
            _element->zoom();
            _element->_stateid = ZOOMING;
            break;
        case 1:
            _element->move();
            _element->_stateid = MOVING;
            break;
        }
        return;
    }
    virtual void onTouchUp( void )
    {
        return;
    }
protected:
    Element * _element;
};

class MovingState: public State
{
public:
    MovingState( void ){}
    explicit MovingState( Element * element): _element(element){line("class Moving"); }
    virtual ~MovingState( void ){line("class ~Moving"); }

    virtual void onTouchDown( void )
    {
        _element->_stateid = ACTIVATED;
        return;
    }
    virtual void onTouchMove( void ) 
    {
        _element->move();
    }
    virtual void onTouchUp( void )
    {
        _element->moved();
        _element->_stateid = ACTIVATED;
        return;
    }
protected:
    Element * _element;
};


class ZoomingState: public State
{
public:
    ZoomingState( void ){}
    explicit ZoomingState( Element * element): _element(element){line("class Zooming"); }
    virtual ~ZoomingState( void ){line("class ~Zoom"); }

    virtual void onTouchDown( void )
    {
        return;
    }
    virtual void onTouchMove( void ) 
    {
        _element->zoom();
    }
    virtual void onTouchUp( void )
    {
        switch(_element->_touchNum)
        {
        case 2:
            _element->zoomed();
            _element->_stateid = ACTIVATED;
            break;
        }
        return;
    }
protected:
    Element * _element;
};

class Console 
{
public:
    Console( void ){};
    virtual ~Console( void )
    {
        for(std::map<std::string, Element*>::iterator iter = _elementlist.begin();
            iter!=_elementlist.end();iter++)
        {
            if (iter->second != NULL)
            {
                delete iter->second;
            }
        }
    }
    
    void run(EventID e,std::string name)
    {

        std::map<std::string, Element*>::iterator iter = _elementlist.find(name);
        if (iter!= _elementlist.end())
        {
            iter->second->run(e);
        }
    }

    void createElement(std::string name)
    {
        Element * element = new Element(name,this);
        element->_stateSet->setState(WAITE,new WaitState(element));
        element->_stateSet->setState(READY,new ReadyState(element));
        element->_stateSet->setState(ACTIVATED,new ActivatedState(element));
        element->_stateSet->setState(MOVING,new MovingState(element));
        element->_stateSet->setState(ZOOMING,new ZoomingState(element));
        _elementlist.insert(std::pair<std::string,Element*>(name,element) );
    }

    void eraseElement(std::string name)
    {
        std::map<std::string, Element*>::iterator iter = _elementlist.find(name);
        if (iter!= _elementlist.end())
        {
            delete iter->second;
            _elementlist.erase(iter);
        }
    }

    void printlist()
    {
        std::cout << std::endl;
        std::cout << " console element list" << std::endl;
        for(std::map<std::string, Element*>::iterator iter = _elementlist.begin();
            iter!=_elementlist.end();iter++)
        {
            iter->second->print();
        }
        std::cout << std::endl;
    }

    


public:
    std::map<std::string, Element *>    _elementlist;

};

int main()
{    
    Console console;

    std::string cmd;
    std::cout << "now,you can create Element,input cmd[create]:";
    std::cin >> cmd;
    while(1)
    {
        if (cmd == "create")
        {
            std::cout << "input element name:" ;
            std::cin >> cmd;
            if (cmd!="")
            {
                console.createElement(cmd);
            }
        }
        else if (cmd == "erase")
        {
            std::cout << "input element name:";
            std::cin >> cmd;
            if (cmd!="")
            {
                console.eraseElement(cmd);
            }
        }
        else if (cmd == "down" || cmd == "move" || cmd == "up")
        {
            EventID e = getEventID(cmd);
            std::cout << "input element name:";
            std::cin >> cmd;
            console.run(e,cmd);
        }
        console.printlist();
        std::cin >> cmd;
    }

    system("PAUSE");

    return 0;
}
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/mumuliang/p/2009793.html