循环数组实现队列

同样也是sicily2302的答案

#ifndef QUEUE_H
#define QUEUE_H
//利用循环数组实现一个队列
template <typename T>
class Queue
{
public:
     Queue();   // construct an empty queue
  ~Queue();  // destructor
  Queue(const Queue &rhs);
  const Queue & operator=(const Queue &rhs);
  bool empty() const;
  bool full() const;
  int size() const;
  bool push(const T &x);//enqueue
  bool pop();//dequeue
  const T & front()const;//returns a reference to the front element
private:
 //using a static array of size 100.  
 int begin;
 int rear;
 T* base;
 int maxsize;
};

template<typename T>
Queue<T>::Queue()
{
 base = (T*) new T[100];
 begin = rear = 0;
 maxsize = 100;
}

template<typename T>
Queue<T>::~Queue()
{
 delete [] base;
}

template<typename T>
bool Queue<T>::full() const
{
 if((rear+1) % maxsize == begin)
  return true;
 else
  return false;
}

template<typename T>
bool Queue<T>::empty() const
{
 if(rear == begin)
  return true;
 else
  return false;
}

template<typename T>
int Queue<T>::size() const
{
 return (rear - begin + maxsize)%maxsize;
}

template<typename T>
bool Queue<T>::push(const T &x)
{
 if(full())
 {
  return false;
 }
 else
 {
  base[rear] = x;
  rear = (rear + 1) % maxsize;
  return true;
 }
}

template<typename T>
bool Queue<T>::pop()
{
 if(empty())
 {
  return false;
 }
 else
 {
  begin = (begin + 1) % maxsize;
  return true;
 }
}

template<typename T>
const T & Queue<T>::front()const
{
 return base[begin];
}

template<typename T>
Queue<T>::Queue(const Queue &rhs)
{
 base = NULL;
 operator=(rhs);
}

template<typename T>
const Queue<T>& Queue<T>::operator=(const Queue &rhs)
{
 if(this != &rhs)
 {
  delete [] base;
  maxsize = rhs.maxsize;
  begin = rhs.begin;
  rear = rhs.rear;
  base = new T[maxsize];
  for(int k = 0 ;k < maxsize;k++)
   base[k] = rhs.base[k];
 }
 return *this;
}

#endif