简单链式队列（C++模版技术实现）

下面代码仅供本人复习数据结构所用，实用性N低，各位飘过吧~~哈哈:>

// 
// C++ 模版技术实现简单链式队列示例. 
// 
 
#include <cstdlib>
#include <iostream>
#include <iomanip>
#include <stdexcept>
 
// 链式队列类模版前置声明. 
template <typename T> class LinkedQueue;
 
//
// 链式队列节点类模版. 
//
template <typename T>
class Node
{
    friend class LinkedQueue<T>;
     
private:
    T _value;
    Node<T> *_pNext;  
     
public:
    Node(void)
        : _pNext(NULL)
    { NULL; }
     
    Node(const T &val) 
        : _value(val)
        , _pNext(NULL)
    { NULL; }
};
 
//
// 链式队列类模版. 
// 采用带头节点和尾指针的单向链表.
// 当队列为空是尾指针指向头节点. 
// 入队时从头结点后接入，出队时从尾节点断开. 
// 
template <typename T>
class LinkedQueue
{
private:
    Node<T> *_pFront, *_pRear;
     
public:
    LinkedQueue(void);
    ~LinkedQueue(void);
    bool isEmpty(void) const;
    size_t getLength(void) const;
    T getFront(void) const;
    void enqueue(const T &val);
    T dequeue(void);
};
 
 
template <typename T>
inline LinkedQueue<T>::LinkedQueue(void)
{ 
    _pFront = new Node<T>();
    _pRear = _pFront;
}
 
 
template <typename T>
LinkedQueue<T>::~LinkedQueue(void)
{
    for (Node<T> *pDel = _pFront->_pNext; NULL != pDel; pDel = _pFront->_pNext)
    {
        _pFront->_pNext = pDel->_pNext;
#if !defined(NDEBUG)
        std::cout << "删除节点：" << pDel->_value << std::endl; 
#endif
        delete pDel;
    }
    delete _pFront;
}
     
     
template <typename T>
inline bool LinkedQueue<T>::isEmpty(void) const
{
    return _pFront == _pRear;
}
 
     
template <typename T>
size_t LinkedQueue<T>::getLength(void) const
{
    size_t len = 0;
    for (Node<T> *pTemp = _pFront->_pNext; NULL != pTemp; ++len)
    { pTemp = pTemp->_pNext; }
     
    return len;
}
 
     
template <typename T>
inline T LinkedQueue<T>::getFront(void) const
{
    return _pFront->_pNext->_value;
}
 
     
template <typename T>
inline void LinkedQueue<T>::enqueue(const T &val)
{
    Node<T>* pNew = new Node<T>(val);
     
    _pRear->_pNext = pNew;
    _pRear = pNew;
}
 
     
template <typename T>
inline T LinkedQueue<T>::dequeue(void)
{
    if (isEmpty()) {
        throw std::underflow_error("队空下溢 !");
    }
     
    Node<T> *pDel = _pFront->_pNext;
    _pFront->_pNext = pDel->_pNext;
    T value = pDel->_value;
    delete pDel;
     
    if (NULL == _pFront->_pNext)
    {
        _pRear = _pFront;
    }
     
    return value;
}
 
//
// 队列测试 
//
int main(void)
{
    LinkedQueue<int> queue;
    const size_t QUEUE_SIZE = 20;
     
    for (size_t i = 0; i < QUEUE_SIZE; ++i)
    {
        queue.enqueue(i);
    }
     
    std::cout << std::endl
              << "队列" << (queue.isEmpty() ? "" : "不") << "为空."
              << std::endl;
     
    for (size_t i = 0; i < QUEUE_SIZE; ++i)
    {
        std::cout << std::setw(3) << queue.dequeue();
    }
     
    // std::cout << std::setw(3) << queue.dequeue();
     
    std::cout << std::endl
              << "队列" << (queue.isEmpty() ? "" : "不") << "为空."
              << std::endl;
     
    return EXIT_SUCCESS;
} 