循环队列模板类（支持动态扩展 | 仿std::vector::resize 静态扩展）

//顺序循环队列 ADT实现
#include <iostream>
#include <algorithm>
using namespace std;

#define maxn 10
#define f 2
//类声明
//ADT 
template <class T>
class Queue{
	public:
		virtual ~Queue(){};
		virtual bool empty()const = 0;
		virtual int size()const = 0;
		virtual T& front() = 0;
		virtual T& back() = 0;
		virtual void pop() = 0;
		virtual void push(const T& elem) = 0;
};
//seqQue
template <class T>
class seqQue: public Queue<T>{
	 public:
	 	seqQue(int iniC = maxn);
		~seqQue();
		virtual bool empty() const override ; 
				bool full() const override ;
		virtual int size() const override ;
		virtual T& front() override;
		virtual T& back() override;
		virtual void pop() override;
		virtual void push(const T& elem) override;
		
		void reMalloc();
		int pFr;
		int pR;
		
		int S;
		int C;
		
		T* Que;
}; 
template <class T>
seqQue<T>::seqQue(int iniC)
{
	C = iniC;
	pFr = pR = -1;
	S = 0;
	Que = new T[C];
}
template <class T>
seqQue<T>::~seqQue(){delete[] Que;};
template <class T>
bool seqQue<T>::full()const{return (pR+1)%C==pFr;}
//Another Possible Policy:
/*
    1 record queueSize
	2 set a tag to record last operation(push or pop) to distinguish full or empty
*/
template <class T>
bool seqQue<T>::empty()const{return pFr == pR;}
template <class T> 
int seqQue<T>::size()const{return S;}
template <class T>
T& seqQue<T>::front()
{
	if(!empty()){
		return Que[pFr+1];
	}else throw "empty";
}
template <class T>
T& seqQue<T>::back()
{
	if(!empty()){
		return Que[pR];
	}else throw "empty";	
}
template <class T>
void seqQue<T>::pop()
{
	if(empty()){
		throw "empty";
	}else{
		pFr = (pFr+1)%C;
		//逻辑删除 
	}
}
template <class T>
void seqQue<T>::reMalloc()
{
	T* nQue = new T[f*C];
	int beg = (pFr+1)%C;
	if(beg < 2)//pFr < 1 -->pFr == 0 or -1:队列未形成循环
	{
		copy(Que+beg,Que+S-1,nQue);//iptF_Iter,iptL_Iter 
	}else
	{
		copy(Que+beg,Que+C,nQue);
		copy(Que,Que+pR,nQue+C-beg+2);//S = C-1;
	} 
	C*=f;
	delete[] Que;
	Que = nQue;
	pFr = -1;
	pR = S-1;
}
template <class T>
void seqQue<T>::push(const T& elem)
{
	if(full())
	{
		reMalloc();	
	}
	pR = (pR+1)%C;
	Que[pR] = elem;
}