Ｃ++容器queue

class template

std::queue

template <class T, class Container = deque<T> > class queue;

先进先出的容器；常用函数：

Member functions

(constructor)

Construct queue (public member function)

empty

Test whether container is empty (public member function)

size

Return size (public member function)

front

Access next element (public member function)

back

Access last element (public member function)

push

Insert element (public member function)

emplace

Construct and insert element (public member function)

pop

Remove next element (public member function)

swap

Swap contents (public member function)

例子：

  

#include <iostream>
#include <queue>

class DoorFSM
{
public:
    /*States*/
    enum States { Closed, Unlocked, Locked, Opened   }; // states

    /*Events*/
    enum Event { Lock, Unlock, Open, Close   };

    /// Constructor
    DoorFSM()
    {
        __Y = Opened;
    }

    /// Destructor
    virtual ~DoorFSM() {}

    /** Get current FSM state
        @returns current FSM state
     */
    States currentState()
    {
        return __Y;
    }

    /** Send event to FSM
        Use this function to send event to DoorFSM After
        you call it given event will be handled, and, if some of
        transition conditions match, appropriate transition will
        be triggered, and currentState() will be changed.
        If this function is called during existing event handling
        process, given event will be added to pending event queue,
        and will be handled after current transition. See examples for details.
    */
    void A( Event e );

protected:
    virtual void enterOpened() = 0;
    virtual void enterLocked() = 0;
    virtual void enterUnlocked() = 0;
    virtual void enterClosed() = 0;

private:
    States __Y;
    std::queue<Event> __events;
    void __processEvent( Event e );

};

void DoorFSM::__processEvent( Event e )
{
    States yOld = __Y;
    bool pass = false;

    switch( __Y )   //transitions
    {
    case Closed:
        if( e == Open )
        {
            //outcome actions
            __Y = Opened;
            pass = true;
        }
        else if( e == Lock )
        {
            //outcome actions
            __Y = Locked;
            pass = true;
        }
        break;
    case Unlocked:
        if( e == Lock )
        {
            //outcome actions
            __Y = Locked;
            pass = true;
        }
        else if( e == Open )
        {
            //outcome actions
            __Y = Opened;
            pass = true;
        }
        break;
    case Locked:
        if( e == Unlock )
        {
            //outcome actions
            __Y = Unlocked;
            pass = true;
        }
        break;
    case Opened:
        if( e == Close )
        {
            //outcome actions
            __Y = Closed;
            pass = true;
        }
        break;
    }

    if( yOld == __Y && !pass )
    {
        return;
    }

    switch( __Y )   // income actions
    {
    case Closed:
        enterClosed();
        break;
    case Unlocked:
        enterUnlocked();
        break;
    case Locked:
        enterLocked();
        break;
    case Opened:
        enterOpened();
        break;
    }
}

void DoorFSM::A( Event e )

{
    bool __empty = __events.empty();
    __events.push( e );

    if( __empty )
    {
        while( !__events.empty() )
        {
            __processEvent( __events.front() );
            __events.pop();
        }
    }
}

class DoorFSMLogic : public DoorFSM
{
protected:
    virtual void enterOpened()
    {
        std::cout << "Enter Opened state." << std::endl;
    }

    virtual void enterLocked()
    {
        std::cout << "Enter Closed state." << std::endl;
    }

    virtual void enterUnlocked()
    {
        std::cout << "Enter Locked state." << std::endl;
    }

    virtual void enterClosed()
    {
        std::cout << "Enter Unlocked state." << std::endl;
    }
};

//测试程序
int main()
{
    DoorFSMLogic door;

    door.A(DoorFSM::Close);
    door.A(DoorFSM::Lock);
    door.A(DoorFSM::Unlock);
    door.A(DoorFSM::Open);

    return 0;
}