Queue.h

#ifndef H_QueueType
#define H_QueueType

#include<iostream>
#include<cassert>

using namespace std;

template<class Type>
class QueueType
{
    public:
  const QueueType<Type>& operator=(const QueueType<Type>&);
      
        bool isEmptyQueue();

        bool isFullQueue();

        void initializeQueue();

       void destroyQueue();

    Type front();

    Type back();

    void addQueue(const Type& QueueElement);

      void deleteQueue();

   QueueType(int QueueSize=100);

      QueueType(const QueueType<Type>& otherQueue);
    
       ~QueueType();

 private:
         int maxQueueSize;
         int count;
   int queueFront;
   int queueRear;
   Type *list;

};

template<class Type>
void QueueType<Type>::initializeQueue()
{
    queueFront=0;
    queueRear=maxQueueSize-1;
    count=0;

}

template<class Type>
bool QueueType<Type>::isEmptyQueue()
{
 
    return(count==0);

}

template<class Type>
bool QueueType<Type>::isFullQueue()
{

    return(count==maxQueueSize);

}

template<class Type>
void QueueType<Type>::destroyQueue()
{

    intializeQueue();

}

template<class Type>
Type QueueType<Type>::front()
{

   assert(!isEmptyQueue());

   return list[queueFront];

}

template<class Type>
Type QueueType<Type>::back()
{

  assert(!isEmptyQueue());
 
  return(list[queueRear]);
}

template<class Type>
void QueueType<Type>::addQueue(const Type& newElement)
{
    if(!isFullQueue())
 {
     queueRear=(queueRear+1)%maxQueueSize;
    
    count++;
  
       list[queueRear]=newElement;
 }

  else
   cerr<<"Cannot add to a full queue."<<endl;

}

template<class Type>
void QueueType<Type>::deleteQueue()
{

    if(!isEmptyQueue())
 {
    count--;
 
    queueFront=(queueFront+1)%maxQueueSize;
 
 
 }

else
    cerr<<"Cannot remove from an empty queue."<<endl;

}

template<class Type>
QueueType<Type>::QueueType(int queueSize)
{

    if(queueSize<=0)
 {
    cerr<<"The size of the array to hold the queue must be positive. "<<endl;
 
   maxQueueSize=100;
 }

    else
  maxQueueSize=queueSize;
   
        queueFront=0;
  queueRear=maxQueueSize-1;
        list=new Type[maxQueueSize];
        assert(list!=NULL);   
}

template<class Type>
QueueType<Type>::~QueueType()
{

delete[]list;

}
#endif