链式队列

#pragma once 

template<class Object>
class Queue
{
public:
    Queue();
    ~Queue();

    bool isEmpty() const;
    const Object& GetFront() const;//拿出队首的数据
    void enqueue(const Object& x);
    Object dequeue();
    void MakeEmpty();
private:
    struct ListNode
    {
        Object element;
        ListNode *next;

        ListNode(const Object& theElement, ListNode *n = 0)
            :element(theElement), next(n)
        {

        }
    };

private:

    ListNode *front;
    ListNode *back;
};

template<class Object>
Queue<Object>::Queue() :front(0), back(0)
{

}

template<class Object>
Queue<Object>::~Queue()
{
    MakeEmpty();
}

template<class Object>
inline bool Queue<Object>::isEmpty() const
{
    return front == 0;
}

//拿出队首的数据
template<class Object>
inline const Object& Queue<Object>::GetFront() const
{
    if (isEmpty())
    {
        throw " Queue is empty.";
    }

    return front->element;
}

//压入新数据
template<class Object>
void Queue<Object>::enqueue(const Object& x)
{
    if (isEmpty())
    {
        back = front = new ListNode(x);
    }
    else
    {
        back = back->next = new ListNode(x);
    }
}

//从队首开始删除数据,同时返回队首节点中的数据
template<class Object>
Object Queue<Object>::dequeue()
{
    Object frontItem = GetFront();

    ListNode *temp = front;
    front = front->next;

    delete temp;

    return frontItem;
}

template<class Object>
void Queue<Object>::MakeEmpty()
{
    while (!isEmpty())
    {
        dequeue();//删除数据
    }
}