C++模板Queue

《C++ primer》中的一个例子，感觉对模板编程很有帮助，便从头到尾实现了一遍。内部机制实际上是一个链表，但对外呈现队列的特性。代码如下：

#ifndef __MYQUEUE_H__
#define __MYQUEUE_H__

#include <iostream>

// 这里必须提前声明
template <typename Type>
class Queue;	

template<typename Type>
std::ostream& operator << (std::ostream &, const Queue<Type> &);

template <typename Type>
class QueueItem {
	// 声明友元关系
	friend class Queue<Type>;
	friend std::ostream& operator << <Type> (std::ostream &, const Queue<Type> &);

	QueueItem(const Type &t) : item(t), next(NULL)
	{}

	Type item;
	QueueItem *next;
};

template <typename Type>
class Queue {
public:
	// 声明友元关系
	friend std::ostream& operator << <Type> (std::ostream &, const Queue<Type> &);

	Queue() : head(NULL), tail(NULL)
	{}

	Queue(const Queue &q) : head(NULL), tail(NULL)
	{
		copy_elems(q);
	}

	Queue& operator= (const Queue &);

	~Queue()
	{
		destroy();
	}

	Type& front()
	{
		if (head == NULL)
			throw exception("Queue is empty.");

		return head->item;
	}

	const Type& front() const
	{
		if (head == NULL)
			throw exception("Queue is empty.");

		return head->item;
	}

	void push(const Type&);

	void pop();

	bool empty() const
	{
		return head == NULL;
	}

private:
	QueueItem<Type> *head;	// 指向Queue头节点
	QueueItem<Type> *tail;	// 指向Queue尾节点
	void copy_elems(const Queue &);
	void destroy();
};

template<typename Type>
Queue<Type>& Queue<Type>::operator= (const Queue &q)
{
	if (&q == this)
		return *this;

	destroy();
	copy_elems(q);
	return *this;
}

// 从尾添加一个节点
template<typename Type>
void Queue<Type>::push(const Type &t)
{
	QueueItem<Type> *tmp = new QueueItem<Type>(t);
	if (empty())
	{
		head = tail = tmp;
	}
	else
	{
		tail->next = tmp;
		tail = tmp;
	}
}

// 从头删除一个节点
template<typename Type>
void Queue<Type>::pop()
{
	if (head != NULL)
	{
		QueueItem<Type> *tmp = head;
		head = tmp->next;
		delete tmp;
	}
}

template<typename Type>
void Queue<Type>::destroy()
{
	while (!empty())
		pop();
}

template<typename Type>
void Queue<Type>::copy_elems(const Queue &q)
{
	QueueItem<Type> *tmp = q.head;
	while (tmp != NULL)
	{
		push(tmp->item);
		tmp = tmp->next;
	}
}

template<typename Type>
std::ostream& operator << (std::ostream &os, const Queue<Type> &q)
{
	QueueItem<Type> *tmp = q.head;

	while (tmp != NULL)
	{
		os << tmp->item << ' ';
		tmp = tmp->next;
	}
	return os;
}

// Queue的特化版本
template <>
class Queue<const char *> {
public:
	// 声明特化版本的 operator<< 为友元
	friend std::ostream& operator << <const char *>
		(std::ostream &os, const Queue<const char *> &q);

	void push(const char *);

	void pop()
	{
		real_queue.pop();
	}

	bool empty() const
	{
		return real_queue.empty();
	}

	std::string& front()
	{
		return real_queue.front();
	}
	
	const std::string& front() const	// 基于const的成员函数重载
	{
		return real_queue.front();
	}

private:
	Queue<std::string> real_queue;
};

void Queue<const char *>::push(const char *val)
{
	real_queue.push(val);
}

template <>
std::ostream& operator << <const char *> (std::ostream &os, const Queue<const char *> &q)
{
	os << q.real_queue;
	return os;
}

#endif

参考：

《C++ primer》