队列（链表形式）实现_c++

template<class T> class Queue;
template<class T> ostream& operator<<(ostream&, const Queue<T>&);
template<class T> class QueueItem{
	friend class Queue<T>;
	friend ostream& operator<< <T> (ostream&, const Queue<T>&);
	QueueItem(const T& t):item(t),next(0){}
    T item;
	QueueItem *next;
};

template<class T> class Queue{
	friend ostream& operator<< <T> (ostream&, const Queue<T>&);
public:
	Queue():head(0), tail(0){}
	Queue(const Queue& rhs);
	Queue& operator=(const Queue&);
	~Queue();
	T& Front() const;
	void Pop();
	void Push(const T&);
	size_t Size() const;
	inline bool Empty() const;
private:
	QueueItem<T> *head;
	QueueItem<T> *tail;
	void CopyElements(const Queue&);
};

template<class T> Queue<T>::Queue(const Queue& rhs):head(0),tail(0)
{
	CopyElements(rhs);
}

template<class T> Queue<T>& Queue<T>::operator=(const Queue& rhs)
{
	if (this == &rhs)
	{
		return *this
	}

	while(!Empty())
	{
		Pop();
	}

	CopyElements(rhs);

	return *this;
}

template<class T> Queue<T>::~Queue()
{
	while (!Empty())
	{
		Pop();
	}
}

template<class T> T& Queue<T>::Front() const
{
	if (Empty())
	{
		exit(1);
	}

	return head->item;
}

template<class T> void Queue<T>::Pop()
{
	if (!Empty())
	{
		QueueItem<T> *p = head;
		head = head->next;
		delete p;
	}
}

template<class T> void Queue<T>::Push(const T& val)
{
	QueueItem<T> *p = new QueueItem<T>(val);
	if (Empty())
	{
		head = tail = p;
	}
	else
	{
		tail->next = p;
		tail = p;
	}
}

template<class T> size_t Queue<T>::Size() const
{
	
	QueueItem<T> *p = head;

	size_t count = 0;

	while(p != 0)
	{
		count++;
		p = p->next;
	}

	return count;
}

template<class T> bool Queue<T>::Empty() const
{
	return head == 0;
}

template<class T> void Queue<T>::CopyElements(const Queue& q)
{
	for (QueueItem<T> *p = q.head; p != 0; p = p->next)
	{
		Push(p->item);
	}
}

template<class T> ostream& operator<<(ostream& os, const Queue<T>& q)
{
	os<<"<";
	for (QueueItem<T> *p = q.head; p != 0; p = p->next)
	{
		os<<p->item<<" ";
	}
	os<<">";
	return os;
}