简单链式队列（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;
}