【队列】循环队列

CircularQueue.h

#ifndef CIRCULARQUEUE_H
#define CIRCULARQUEUE_H

int default_size = 10;

#include<iostream>
//CircularQueue
template<typename T>
class CircularQueue{
public:
	typedef T& reference;
	CircularQueue(int size = default_size);//constructor
	~CircularQueue();//destructor
	void push(const T value);//push
	void pop();//pop
	reference get_front();//front
	reference get_back();//back
	bool empty();//whether CircularQueue is empty or not
	int size();//get length
private:
	void renew(int size);//realloc CircularQueue size
private:
	T* element;
	int front;
	int rear;
	int queue_size;
};
//constructor
template<typename T>
CircularQueue<T>::CircularQueue(int size = default_size):front(0),rear(0){
	if (size > 0){
		element = new T[size];
		queue_size = size;
	}
	else{
		element = new T[default_size];
		queue_size = default_size;
	}
}
//destructor
template<typename T>
CircularQueue<T>::~CircularQueue(){
	delete[] element;
	front = 0;
	rear = 0;
	queue_size = 0;
}
//push
template<typename T>
void CircularQueue<T>::push(const T value){
	if ((rear + 1) % queue_size == front){
		renew(queue_size+default_size);
		queue_size += default_size;
	}
	element[rear] = value;
	rear = (rear + 1) % queue_size;
}
//pop
template<typename T>
void CircularQueue<T>::pop(){
	if (empty()){
		std::cout << "there is no element in queue" << std::endl;
		exit(1);
	}
	front = (front + 1) % queue_size;
}
//front
template<typename T>
typename CircularQueue<T>::reference CircularQueue<T>::get_front(){
	if (empty()){
		std::cout << "there is no element in queue" << std::endl;
		exit(1);
	}
	return element[front];
}
//back
template<typename T>
typename CircularQueue<T>::reference CircularQueue<T>::get_back(){
	if (empty()){
		std::cout << "there is no element in queue" << std::endl;
		exit(1);
	}
	return element[(rear - 1 + queue_size) % queue_size];
}
//whether CircularQueue is empty or not
template<typename T>
bool CircularQueue<T>::empty(){
	return front == rear ? true : false;
}
//get length
template<typename T>
int CircularQueue<T>::size(){
	return (rear - front + queue_size) % queue_size;
}
//realloc CircularQueue size
template<typename T>
void CircularQueue<T>::renew(int size){
	T* p = element;
	element = new T[size];
	int i = 0;
	while (front%queue_size != rear){
		element[i++] = p[front++];
	}
	front = 0;
	rear = queue_size - 1;
}

#endif

main.cpp

#include"CircularQueue.h"
using namespace std;

int main(){
	CircularQueue<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;
}