Implement the Queue ADT using array based approach Using C

Implement the Queue ADT using array – based approach. Using C++ programming Language

#include \"QueueArray.h\"

template <typename DataType>
QueueArray<DataType>::QueueArray(int maxNumber)
{
}

template <typename DataType>
QueueArray<DataType>::QueueArray(const QueueArray& other)
{
}

template <typename DataType>
QueueArray<DataType>& QueueArray<DataType>::operator=(const QueueArray& other)
{
}

template <typename DataType>
QueueArray<DataType>::~QueueArray()
{
}

template <typename DataType>
void QueueArray<DataType>::enqueue(const DataType& newDataItem) throw (logic_error)
{
}

template <typename DataType>
DataType QueueArray<DataType>::dequeue() throw (logic_error)
{
   DataType temp;
   return temp;
}

template <typename DataType>
void QueueArray<DataType>::clear()
{
}

template <typename DataType>
bool QueueArray<DataType>::isEmpty() const
{
   return false;
}

template <typename DataType>
bool QueueArray<DataType>::isFull() const
{
   return false;
}

template <typename DataType>
void QueueArray<DataType>::putFront(const DataType& newDataItem) throw (logic_error)
{
}

template <typename DataType>
DataType QueueArray<DataType>::getRear() throw (logic_error)
{
   DataType temp;
   return temp;
}

template <typename DataType>
int QueueArray<DataType>::getLength() const
{
   return -1;
}

//--------------------------------------------------------------------

template <typename DataType>
void QueueArray<DataType>::showStructure() const
// Array implementation. Outputs the data items in a queue. If the
// queue is empty, outputs \"Empty queue\". This operation is intended
// for testing and debugging purposes only.

{
int j; // Loop counter

if ( front == -1 )
cout << \"Empty queue\" << endl;
else
{
cout << \"Front = \" << front << \" Back = \" << back << endl;
for ( j = 0 ; j < maxSize ; j++ )
cout << j << \"\\t\";
cout << endl;
if ( back >= front )
for ( j = 0 ; j < maxSize ; j++ )
if ( ( j >= front ) && ( j <= back ) )
cout << dataItems[j] << \"\\t\";
else
cout << \" \\t\";
else
for ( j = 0 ; j < maxSize ; j++ )
if ( ( j >= front ) || ( j <= back ) )
cout << dataItems[j] << \"\\t\";
else
cout << \" \\t\";
cout << endl;
}
}

QueueArray.h

___-----------------------------------------------------------------------------

#ifndef QUEUEARRAY_H
#define QUEUEARRAY_H

#include <stdexcept>
#include <iostream>

using namespace std;

#include \"Queue.h\"

template <typename DataType>
class QueueArray : public Queue<DataType> {
public:
QueueArray(int maxNumber = Queue<DataType>::MAX_QUEUE_SIZE);
QueueArray(const QueueArray& other);
QueueArray& operator=(const QueueArray& other);
~QueueArray();

void enqueue(const DataType& newDataItem) throw (logic_error);
DataType dequeue() throw (logic_error);

void clear();

bool isEmpty() const;
bool isFull() const;

void putFront(const DataType& newDataItem) throw (logic_error);
DataType getRear() throw (logic_error);
int getLength() const;

void showStructure() const;

private:
int maxSize;
int front;
int back;
DataType* dataItems;
};

#endif

Solution

QueueArray.cpp

#include \"QueueArray.h\"

template <typename DataType>
QueueArray<DataType>::QueueArray(int maxNumber)
{
   maxSize = maxNumber;
   this->dataItems = new DataType[maxSize];
   front = -1;
   back = -1;

}

template <typename DataType>
QueueArray<DataType>::QueueArray(const QueueArray& other)
{
   dataItems = new DataType[maxSize];

   for (int i = 0; i <= top; i++)
   {
       dataItems[i] = other.dataItems[i];
   }

}

template <typename DataType>
QueueArray<DataType>& QueueArray<DataType>::operator=(const QueueArray& other)
{
   if (maxSize < other.maxSize)
   {
       delete[] dataItems;
       dataItems = new dataType[other.maxSize];
   }

   maxSize = other.maxSize;
   top = other.top;

   for (int i = 0; i <= top; i++)
   {
       dataItems[i] = other.dataItems[i];
   }

   return *this;
}

template <typename DataType>
QueueArray<DataType>::~QueueArray()
{
   this->clear();
}

template <typename DataType>
void QueueArray<DataType>::enqueue(const DataType& newDataItem) throw (logic_error)
{
   if (this->isFull())
       throw logic_error(\"Queue is Full.\");
   if (this->isEmpty())
   {
       dataItems[back + 1] = newDataItem;
       back = (++back) % maxSize;
       front++;
   }
   else if (back == 7 && !isFull())
   {
       back = 0;
       dataItems[back] = newDataItem;
   }
   else {
       back = (++back) % maxSize;
       dataItems[back] = newDataItem;
   }

}

template <typename DataType>
DataType QueueArray<DataType>::dequeue() throw (logic_error)
{
   if (this->isEmpty())
       throw logic_error(\"Queue is empty. \");

   if (getLength() == 1)
   {
       DataType temp = dataItems[this->front];
       clear();
       return temp;
   }

   else {
       DataType temp;
       temp = dataItems[this->front];
       front++;
       return temp;
   }
}

template <typename DataType>
void QueueArray<DataType>::clear()
{
   front = -1;
   back = -1;
}

template <typename DataType>
bool QueueArray<DataType>::isEmpty() const
{
   return (front == -1);
}

template <typename DataType>
bool QueueArray<DataType>::isFull() const
{
   return (getLength() == this->maxSize);
}

template <typename DataType>
void QueueArray<DataType>::putFront(const DataType& newDataItem) throw (logic_error)
{
   if (isFull())
       throw logic_error(\"Queue is Full.\");
   else {
       if (isEmpty())
       {
           front = 0;
           back = 0;
       }
       else {
           front--;
           if (front < 0)
               front = (maxSize - 1);
       }

       dataItems[front] = newDataItem;
   }

}

template <typename DataType>
DataType QueueArray<DataType>::getRear() throw (logic_error)
{
   int cursor = -1;
   if (isEmpty()) {
       throw logic_error(\"Queue is Empty.\");
   }
   else {
       cursor = back;
       if (front == back)
       {
           front = -1;
           back = -1;
       }
       else
       {
           --back;
           if (back < 0)
               back = (maxSize - 1);
       }

       return dataItems[cursor];
   }
  
}

template <typename DataType>
int QueueArray<DataType>::getLength() const
{
   if (front > back)
       return (back - front + maxSize + 1);
   else
       return back - front + 1;
}

//--------------------------------------------------------------------

template <typename DataType>
void QueueArray<DataType>::showStructure() const
// Array implementation. Outputs the data items in a queue. If the
// queue is empty, outputs \"Empty queue\". This operation is intended
// for testing and debugging purposes only.

{
   int j;   // Loop counter

   if (front == -1)
       cout << \"Empty queue\" << endl;
   else
   {
       cout << \"Front = \" << front << \" Back = \" << back << endl;
       for (j = 0; j < maxSize; j++)
           cout << j << \"\\t\";
       cout << endl;
       if (back >= front)
           for (j = 0; j < maxSize; j++)
               if ((j >= front) && (j <= back))
                   cout << dataItems[j] << \"\\t\";
               else
                   cout << \" \\t\";
       else
           for (j = 0; j < maxSize; j++)
               if ((j >= front) || (j <= back))
                   cout << dataItems[j] << \"\\t\";
               else
                   cout << \" \\t\";
       cout << endl;
   }
}

QueueArray.h

// QueueArray.h

#ifndef QUEUEARRAY_H
#define QUEUEARRAY_H

#include <stdexcept>
#include <iostream>

using namespace std;

#include \"Queue.h\"

template <typename DataType>
class QueueArray : public Queue<DataType> {
public:
   QueueArray(int maxNumber = Queue<DataType>::MAX_QUEUE_SIZE);
   QueueArray(const QueueArray& other);
   QueueArray& operator=(const QueueArray& other);
   ~QueueArray();

   void enqueue(const DataType& newDataItem) throw (logic_error);
   DataType dequeue() throw (logic_error);

   void clear();

   bool isEmpty() const;
   bool isFull() const;

   void putFront(const DataType& newDataItem) throw (logic_error);
   DataType getRear() throw (logic_error);
   int getLength() const;

   void showStructure() const;

private:
   int maxSize;
   int front;
   int back;
   DataType* dataItems;
};

#endif

Queue.h

#ifndef QUEUE_H
#define QUEUE_H

#include <stdexcept>
#include <iostream>

using namespace std;

#pragma warning( disable : 4290 )

//--------------------------------------------------------------------

template <typename DataType>
class Queue {
public:
   static const int MAX_QUEUE_SIZE = 8;

   virtual ~Queue();

   virtual void enqueue(const DataType& newDataItem) throw (logic_error) = 0;
   virtual DataType dequeue() throw (logic_error) = 0;

   virtual void clear() = 0;

   virtual bool isEmpty() const = 0;
   virtual bool isFull() const = 0;

  
#if LAB7_TEST2
   virtual void putFront(const DataType& newDataItem) throw (logic_error) = 0;
   virtual DataType getRear() throw (logic_error) = 0;
#endif
#if LAB7_TEST3
   virtual int getLength() const = 0;
#endif

   virtual void showStructure() const = 0;
};

template <typename DataType>
Queue<DataType>::~Queue()
// Not worth having a separate class implementation file for the destuctor
{}

#endif       // #ifndef QUEUE_H