【队列】链式队列

LinkedQueue.h

#ifndef LINKEDQUEUE_H
#define LINKEDQUEUE_h

#include<iostream>
//queue node
template<typename T>
struct queue_node{
	typedef queue_node<T>* pointer;
	T data;
	pointer next;
	queue_node() :next(NULL){}
	queue_node(const T value) :data(value), next(NULL){}
};
//LinkedQueue
template<typename T>
class LinkedQueue{
public:
	typedef T value_type;
	typedef T* pointer;
	typedef T& reference;
	typedef queue_node<T>* linked_type;
	LinkedQueue();//constructor
	~LinkedQueue();//destructor
	void push(const T value);//push
	void pop();//pop
	reference get_front();//front
	reference get_back();//back
	bool empty();//whether LinkedQueue is empty or not
	int size();//get length
private:
	void clear();//clear LinkedQueue
private:
	linked_type front;
	linked_type rear;
};
//constructor
template<typename T>
LinkedQueue<T>::LinkedQueue() :front(new queue_node<T>()), rear(front){}
//destructor
template<typename T>
LinkedQueue<T>::~LinkedQueue(){
	clear();
	delete front;
	front = NULL;
	rear = NULL;
}
//push
template<typename T>
void LinkedQueue<T>::push(const T value){
	linked_type p = new queue_node<T>(value);
	rear->next = p;
	rear = p;
}
//pop
template<typename T>
void LinkedQueue<T>::pop(){
	if (empty()){
		std::cout << "there is no element in queue" << std::endl;
		exit(1);
	}
	linked_type p = front->next;
	front->next = p->next;
	if (rear == p)
		rear = front;
	delete p;
}
//front
template<typename T>
typename LinkedQueue<T>::reference LinkedQueue<T>::get_front(){
	if (empty()){
		std::cout << "there is no element in queue" << std::endl;
		exit(1);
	}
	return front->next->data;
}
//back
template<typename T>
typename LinkedQueue<T>::reference LinkedQueue<T>::get_back(){
	if (empty()){
		std::cout << "there is no element in queue" << std::endl;
		exit(1);
	}
	return rear->data;
}
//whether LinkedQueue is empty or not
template<typename T>
bool LinkedQueue<T>::empty(){
	return front == rear ? true : false;
}
//get length
template<typename T>
int LinkedQueue<T>::size(){
	int count = 0;
	linked_type p = front->next;
	while (p != NULL){
		p = p->next;
		count++;
	}
	return count;
}
//clear LinkedQueue
template<typename T>
void LinkedQueue<T>::clear(){
	rear = front;
	linked_type p = front->next;
	linked_type q;
	front->next = NULL;
	while (p != NULL){
		q = p;
		p = p->next;
		delete q;
	}
}

#endif 

main.cpp

#include"LinkedQueue.h"
using namespace std;

int main(){
	LinkedQueue<int> int_queue;
	cout << int_queue.size() << endl; //0
	cout << boolalpha << int_queue.empty() << endl;//true

	for (int i = 1; i < 10; i++){
		int_queue.push(i);
	}

	cout << int_queue.size() << endl; //9
	cout << int_queue.get_front() << endl;//1
	cout << int_queue.get_back() << endl;//9
	cout << boolalpha << int_queue.empty() << endl;//false

	int_queue.pop();
	int_queue.pop();
	int_queue.pop();
	cout << int_queue.get_front() << endl;//4
	cout << int_queue.get_back() << endl;//9

	int_queue.push(10);
	int_queue.push(11);
	cout << int_queue.get_front() << endl;//4
	cout << int_queue.get_back() << endl;//11

	int_queue.push(12);
	int_queue.push(13);
	int_queue.push(14);
	cout << int_queue.size() << endl; //11
	cout << int_queue.get_front() << endl;//4
	cout << int_queue.get_back() << endl;//14

	return 0;
}