队列是一种限定存取位置的线性表，允许插入的一端叫做队尾（rear），允许删除的一端叫做队首（front）。
队列具有FIFO的性质
队列的存储表示也有两种方式：基于数组的，基于列表的。基于数组的叫做顺序队列，基于列表的叫做链式队列。
一下是基于动态数组的顺序队列的模板类的实现。
顺序队列的抽象基类如下所示：只提供了接口和显式的默认构造函数和析构函数，在派生类中调用。
#ifndef QUEUE
#define QUEUE
//队列的抽象基类
template<class T>
class Queue
{
public:
Queue(){}
~Queue(){}
virtual bool EnQueue(const T& x)=0;
virtual bool DeQueue(T& x)=0;
virtual bool getFront(T& x)const=0;
virtual bool IsEmpty()const=0;
virtual bool IsFull()const=0;
virtual int getSize()const=0;
};
#endif顺序队列的具体实现如下：（覆盖所有纯虚函数的接口，并提供自己的接口和数据成员）
/////////////////////////
#include"Stack.h"
#include <iostream>
//#include <cstdlib>
#include <cassert>
using namespace std;
template<class T>
class SeqQueue:public Queue<T>
{
public:
SeqQueue(int sz=10):front(0),rear(0),maxSize(sz),elements(new T[sz]){assert(elements!=NULL);}
~SeqQueue(){delete []elements;}
SeqQueue(const SeqQueue<T>& rhs);
SeqQueue<T>& operator=(const SeqQueue<T>& rhs);
bool EnQueue(const T& x);
bool DeQueue(T& x);
bool getFront(T& x)const;
bool IsEmpty()const{return (rear==front)?true:false;} //判断空
bool IsFull()const{return ((rear+1)%maxSize==front)?true:false;} //判断满
int getSize()const{return (rear-front+maxSize)%maxSize;} //检测大小，+maxSize表示非负
void makeEmpty(){front=rear=0;}
friend ostream& operator<< <T>(ostream& os,const SeqQueue<T>& rhs);//注意<T>
protected:
int front,rear;
T* elements;
int maxSize;
};
template<class T>
bool SeqQueue<T>::EnQueue(const T& x)
{
if(IsFull())
return false;
elements[rear]=x;
rear=(rear+1)%maxSize;//注意不是++rear
return true;
}
template<class T>
bool SeqQueue<T>::DeQueue(T& x)
{
if(IsEmpty())
return false;
x=elements[front];
front=(front+1)%maxSize;
return true;
}
template<class T>
bool SeqQueue<T>::getFront(T& x)const
{
if(IsEmpty())
return false;
x=elements[front];
return true;
}
template<class T>
ostream& operator<<(ostream& os,const SeqQueue<T>& rhs)
{
os<<"front="<<rhs.front<<" "<<"rear="<<rhs.rear<<endl;
os<<"elements: ";
for(int i=0;i<rhs.getSize();++i){
os<<rhs.elements[(rhs.front+i)%rhs.maxSize]<<" "; //注意遍历方法
}
os<<endl;
return os;
}
template<class T>
SeqQueue<T>::SeqQueue(const SeqQueue<T>& rhs)
{
front=rhs.front;
rear=rhs.rear;
maxSize=rhs.maxSize;
T* dest=new T[maxSize];
T* src=rhs.elements;
elements=dest;
for(int i=0;i<rhs.getSize();++i){
dest[(front+i)%maxSize]=src[(front+i)%maxSize];
}
}
template<class T>
SeqQueue<T>& SeqQueue<T>::operator=(const SeqQueue<T>& rhs)
{
delete[] elements;
makeEmpty();
front=rhs.front;
rear=rhs.rear;
maxSize=rhs.maxSize;
T* dest=new T[maxSize];
T* src=rhs.elements;
elements=dest;
for(int i=0;i<rhs.getSize();++i){
dest[(front+i)%maxSize]=src[(front+i)%maxSize];
}
return *this;
}
int main(int argc, char* argv[])
{
SeqQueue<int> s(5);
int a=1,b=2,c=3,d=4,e=0;
s.EnQueue(a);
s.EnQueue(b);
s.EnQueue(c);
s.EnQueue(d);
cout<<s;
s.DeQueue(e);
s.DeQueue(e);
cout<<s;
cout<<"getSize(): "<<s.getSize()<<endl;
cout<<boolalpha;
cout<<"IsEmpty(): "<<s.IsEmpty()<<endl;
cout<<"IsFull(): "<<s.IsFull()<<endl;
cout<<noboolalpha;
s.getFront(e);
cout<<"getFront(): "<<e<<endl;
SeqQueue<int> s1(s),s2;
cout<<s1;
s2=s;
cout<<s2;
system("pause");
return 0;
}测试结果如下：
front=0 rear=4 elements: 1 2 3 4 front=2 rear=4 elements: 3 4 getSize(): 2 IsEmpty(): false IsFull(): false getFront(): 3 front=2 rear=4 elements: 3 4 front=2 rear=4 elements: 3 4 请按任意键继续. . .
注意事项：
1.该实现是正对动态数组存储的循环队列，在逻辑上构成了一个环。
2.rear指向实际队尾位置的下一个位置，front指向的是真正的对头元素所在的位置。
3.初始化时rear=front=0
4.判断空对：front=rear
5.判断满：（rear+1）%maxSize=front。让rear指向front的前一个位置就认为队列已满，所以最多只能存储maxSize-1个元素。这是为了和队列空的判断相区别。
6.对头指正进1：front=（front+1）%maxSize
7.队尾指针进1：rear=（rear+1）% maxSize
原文地址：http://blog.csdn.net/u013467442/article/details/46604717
