队列（Queue）

#ifndef QUEUETP_H_
#define QUEUETP_H_
 
template<typename Item>
class QueueTP
{
private:
	class Node
	{
	public:
		Item item;
		Node* next;
		Node(const Item& i) :item{ i }, next{ nullptr } {}
	};
 
	static const int Q_SIZE = 10;
 
	Node* head;
	Node* tail;
	int items;
	const int qsize;
public:
	QueueTP(int qs = Q_SIZE);
	~QueueTP();
	bool isempty()const { return items == 0; }
	bool isfull()const { return items == qsize; }
	Item& front()const;
	Item& back()const;
	void enqueue(const Item& item);
	Item& dequeue();
	void clear();
};
 
template<typename Item>
QueueTP::QueueTP(int qs)
	: qsize{ qs }
{
	head = tail = nullptr;
	items = 0;
}
 
template<typename Item>
QueueTP::~QueueTP()
{
	Node* temp;
	while (head != nullptr)
	{
		temp = head;
		head = head->next;
		delete temp;
	}
}
 
template<typename Item>
Item& QueueTP::front() const
{
	if (isempty() == false)
	{
		return head->item;
	}
}
 
template<typename Item>
Item& QueueTP::back() const
{
	if (isempty() == false)
	{
		return tail->item;
	}
}
 
template<typename Item>
void QueueTP::enqueue(const Item& item)
{
	if (isfull() == true)
	{
		return;
	}
 
	Node* newNode = new Node(item);
	items++;
	if (head == nullptr)
	{
		head = newNode;
	}
	else
	{
		tail->next = newNode;
	}
 
	tail = newNode;
}
 
template<typename Item>
Item& QueueTP::dequeue()
{
	if (isempty() == false)
	{
		Item i = head->item;
		items--;
		Node* temp = head;
		if (items == 0)
		{
			head = tail = nullptr;
		}
		else
		{
			head = head->next;
		}
		delete temp;
 
		return i;
	}
}
 
template<typename Item>
void QueueTP::clear()
{
	while (isempty() != true)
	{
		dequeue();
	}
}
 
#endif // !QUEUETP_H_