数据结构之循环队列（顺序表存储）——C++模板类实现

基于数组存储形式的循环队列实现 
循环队列的基于数组的存储表示亦称为顺序队列，用一个一维数组elem[maxSize]来实现，其中为了区别队列空与满，该数组中最多存储maxSize-1个元素，如此一来，判断循环队列满的条件便是：
（_rear + 1) % maxSize == _rear
而判断循环队列空的条件则是：
_rear == _front 
之所以要取模maxSize是为了节省空间否则，已经出队列的空间不能再用。这样，求队列中元素的个数则为：
len = (_rear - _front + maxSize) % maxSize

#ifndef QUEUE_H_INCLUDED
#define QUEUE_H_INCLUDED
#include <bits/stdc++.h>
const int maxSize = 284;
template<class T>
class Queue {
public:
Queue() {std::cout << "Constructing a Queue default" << std::endl;}
~Queue() {std::cout << "Destructing a Queue default" << std::endl;}
virtual void EnQueue(T x) = 0;
virtual bool DeQueue(T& x) = 0;
virtual bool GetFront(T& x) = 0;
virtual void MakeEmpty() = 0;
virtual bool IsEmpty() const = 0;
virtual bool IsFull() const = 0;
virtual int GetSize() const = 0;
};

#endif // QUEUE_H_INCLUDED

#ifndef SEQQUEUE_H_INCLUDED
#define SEQQUEUE_H_INCLUDED
#include "Queue.h"
#include <bits/stdc++.h>

using namespace std;

template<class T>
class SeqQueue : public Queue<T> {
public:
SeqQueue(int sz = 10);
~SeqQueue() {MakeEmpty(); cout << "Destructing seqQueue default" << endl;}
void EnQueue(T x);
bool DeQueue(T& x);
bool GetFront(T& x);
void MakeEmpty();
bool IsEmpty() const;
bool IsFull() const;
int GetSize() const;
private:
int _rear, _front;
T *elem;
int maxSize;
};

template<class T>
SeqQueue<T>::SeqQueue(int sz) : _front(0) , _rear(0), maxSize(sz) {
cout << "Constructing a SeqQueue" << endl;
elem = new T[maxSize];
assert(elem != NULL);
}

template<class T>
void SeqQueue<T>::EnQueue(T x) {
if(IsFull() == true) {
cerr << "SeqQueue is full" << endl;
exit(1);
}
elem[_rear] = x;
_rear = (_rear + 1) % maxSize;
return ;
}

template<class T>
bool SeqQueue<T>::DeQueue(T& x) {
if(IsEmpty() == true) {
cerr << "SeqQueue is empty" << endl;
return false;
}
x = elem[_front];
_front = (_front + 1) % maxSize;
}

template<class T>
bool SeqQueue<T>::GetFront(T& x) {
if(IsEmpty() == true) {
cerr << "SeqQueue is empty" << endl;
return false;
}
x = elem[_front];
return true;
}

template<class T>
void SeqQueue<T>::MakeEmpty() {
if(IsEmpty() == true) return ;
delete[] elem;
_front = _rear = 0;
return ;
}

template<class T>
bool SeqQueue<T>::IsEmpty() const {
return _front == _rear ? true : false;
}

template<class T>
bool SeqQueue<T>::IsFull() const {
return (_rear + 1) % maxSize == _front ? true : false;
}

template<class T>
int SeqQueue<T>::GetSize() const {
return (_rear - _front + maxSize) % maxSize;
}

#endif // SEQQUEUE_H_INCLUDED

/**
* Circulr queue can only store maxSize-1 elements at most!
*/
#include <iostream>
#include "SeqQueue.h"
using namespace std;

int main()
{
SeqQueue<int> q;
q.EnQueue(284);
q.EnQueue(220);
q.EnQueue((int)rand());
cout << q.GetSize() << endl;
int ele;
if(q.GetFront(ele)) {
cout << ele << endl;
}
if(q.DeQueue(ele)) {
cout << ele << endl;
cout << q.GetSize() << endl;
}
q.MakeEmpty();
cout << q.GetSize() << endl;
return 0;
}