zoukankan      html  css  js  c++  java

  • 状态模式的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;
    }
  • 相关阅读:
    JQuery替换空字符串和正则表达式校验时间格式
    数据库升级，给某张表增加字段，防止重复升级时sql脚本报错
    将jar包安装到本地repository中
    springCloud集成常用组件（持续更新）
    记一次springboot配置事务@transactional失效的事故
    分布式锁实现（Redis和zookeeper）
    springCloud集成zookeper
    zookeeper学习相关
    springboot集成activeMq
    springboot集成redis
  • 原文地址：https://www.cnblogs.com/mumuliang/p/2009793.html
Copyright © 2011-2022 走看看