c++单链表实现队列

 通过两个链表节点指针实现队列，一个当作队头，一个当作队尾，入队就是往尾节点后插入，退队就是删除头节点

template<class T>
struct ListNode {
	T data;
	ListNode<T> *next;
	ListNode(const T & data) {
		this->data = data;
		this->next = nullptr;
	}
};

template<class T>
class Queue {
public:
	Queue();
	Queue(const Queue<T> & q);
	~Queue();
	void enQueue(const T & elem); // 入队
	void deQueue(); // 退队
	const T & front() const { return m_head->data; } // 返回队头元素
	const T & back() const { return m_tail->data; } // 返回队尾元素
	const size_t size() const { return m_size; } // 返回队列长度
	bool empty() const { return 0 == m_size; } // 判断队列是否为空
private:
	ListNode<T> *m_head, *m_tail; // 记录头节点和尾节点
	size_t m_size;
};

template<class T>
Queue<T>::Queue()
{
	m_head = m_tail = nullptr;
	m_size = 0;
}

template<class T>
Queue<T>::Queue(const Queue<T>& q)
{
	ListNode<T> * temp = q.m_head;
	while (nullptr != temp) {
		enQueue(temp->data);
		temp = temp->next;
	}
}

template<class T>
Queue<T>::~Queue()
{
	ListNode<T> * temp = nullptr;
	while (nullptr != m_head) {
		temp = m_head;
		m_head = m_head->next;
		delete temp;
		temp = nullptr;
	}
	delete temp;
	temp = nullptr;
}

template<class T>
void Queue<T>::enQueue(const T & elem)
{
	if (empty()) {
		m_head = m_tail = new ListNode<T>(elem);
	}
	else {
		m_tail->next = new ListNode<T>(elem);
		m_tail = m_tail->next;
	}
	m_size++;
}

template<class T>
void Queue<T>::deQueue()
{
	/*try {
		if (empty()) {
			throw std::out_of_range;
		}
		else {
			ListNode<T> *temp = m_head;
			m_head = m_head->next;
			delete temp;
			temp = nullptr;
			m_size--;
		}
	}
	catch (std::out_of_range err) {
		
	}*/
	if (!empty()) {
		ListNode<T> *temp = m_head;
		m_head = m_head->next;
		delete temp;
		temp = nullptr;
		m_size--;
	}
}

int main() {
	Queue<int> q;
	q.deQueue();
	q.enQueue(1);
	q.enQueue(2);
	q.enQueue(3);
	Queue<int> q2(q);
	q2.deQueue();
	q.deQueue();
	q.deQueue();
	q.deQueue();
	q.enQueue(3);
	return 0;
}