Implement the Queue ADT using array – based approach. Using C++ prog.pdf

Implement the Queue ADT using array – based approach. Using C++ programming Language
#include \"QueueArray.h\"
template
QueueArray::QueueArray(int maxNumber)
{
}
template
QueueArray::QueueArray(const QueueArray& other)
{
}
template
QueueArray& QueueArray::operator=(const QueueArray& other)
{
}
template
QueueArray::~QueueArray()
{
}
template
void QueueArray::enqueue(const DataType& newDataItem) throw (logic_error)
{
}
template
DataType QueueArray::dequeue() throw (logic_error)
{
DataType temp;
return temp;
}
template
void QueueArray::clear()
{
}
template
bool QueueArray::isEmpty() const
{
return false;
}
template
bool QueueArray::isFull() const
{
return false;
}
template
void QueueArray::putFront(const DataType& newDataItem) throw (logic_error)
{
}
template
DataType QueueArray::getRear() throw (logic_error)
{
DataType temp;
return temp;
}
template
int QueueArray::getLength() const
{
return -1;
}
//--------------------------------------------------------------------
template
void QueueArray::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 = front )
for ( j = 0 ; j = front ) && ( j = front ) || ( j dataItems = new DataType[maxSize];
front = -1;
back = -1;
}
template
QueueArray::QueueArray(const QueueArray& other)
{
dataItems = new DataType[maxSize];
for (int i = 0; i <= top; i++)
{
dataItems[i] = other.dataItems[i];
}
}
template
QueueArray& QueueArray::operator=(const QueueArray& other)
{
if (maxSize < other.maxSize)
{
delete[] dataItems;
dataItem.

1. Implement the Queue ADT using array – based approach. Using C++ programming Language
#include \"QueueArray.h\"
template
QueueArray::QueueArray(int maxNumber)
{
}
template
QueueArray::QueueArray(const QueueArray& other)
{
}
template
QueueArray& QueueArray::operator=(const QueueArray& other)
{
}
template
QueueArray::~QueueArray()
{
}

template
void QueueArray::enqueue(const DataType& newDataItem) throw (logic_error)
{
}
template
DataType QueueArray::dequeue() throw (logic_error)
{
   DataType temp;
   return temp;
}
template
void QueueArray::clear()
{
}
template
bool QueueArray::isEmpty() const

2. {
   return false;
}
template
bool QueueArray::isFull() const
{
   return false;
}
template
void QueueArray::putFront(const DataType& newDataItem) throw (logic_error)
{
}
template
DataType QueueArray::getRear() throw (logic_error)
{
   DataType temp;
   return temp;
}
template
int QueueArray::getLength() const
{
   return -1;
}
//--------------------------------------------------------------------
template
void QueueArray::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;

3. for ( j = 0 ; j < maxSize ; j++ )
cout << j << \" \";
cout << endl;
if ( back >= front )
for ( j = 0 ; j < maxSize ; j++ )
if ( ( j >= front ) && ( j <= back ) )
cout << dataItems[j] << \" \";
else
cout << \" \";
else
for ( j = 0 ; j < maxSize ; j++ )
if ( ( j >= front ) || ( j <= back ) )
cout << dataItems[j] << \" \";
else
cout << \" \";
cout << endl;
}
}
QueueArray.h
___-----------------------------------------------------------------------------
#ifndef QUEUEARRAY_H
#define QUEUEARRAY_H
#include
#include
using namespace std;
#include \"Queue.h\"
template
class QueueArray : public Queue {
public:
QueueArray(int maxNumber = Queue::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();

4. 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
QueueArray::QueueArray(int maxNumber)
{
   maxSize = maxNumber;
   this->dataItems = new DataType[maxSize];
   front = -1;
   back = -1;
}
template
QueueArray::QueueArray(const QueueArray& other)
{
   dataItems = new DataType[maxSize];
   for (int i = 0; i <= top; i++)
   {
       dataItems[i] = other.dataItems[i];
   }
}

5. template
QueueArray& QueueArray::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
QueueArray::~QueueArray()
{
   this->clear();
}

template
void QueueArray::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())
   {

6.        back = 0;
       dataItems[back] = newDataItem;
   }
   else {
       back = (++back) % maxSize;
       dataItems[back] = newDataItem;
   }
}
template
DataType QueueArray::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
void QueueArray::clear()
{
   front = -1;
   back = -1;
}
template
bool QueueArray::isEmpty() const
{
   return (front == -1);

7. }
template
bool QueueArray::isFull() const
{
   return (getLength() == this->maxSize);
}
template
void QueueArray::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
DataType QueueArray::getRear() throw (logic_error)
{
   int cursor = -1;
   if (isEmpty()) {
       throw logic_error(\"Queue is Empty.\");
   }
   else {
       cursor = back;
       if (front == back)
       {

8.            front = -1;
           back = -1;
       }
       else
       {
           --back;
           if (back < 0)
               back = (maxSize - 1);
       }
       return dataItems[cursor];
   }

}
template
int QueueArray::getLength() const
{
   if (front > back)
       return (back - front + maxSize + 1);
   else
       return back - front + 1;
}
//--------------------------------------------------------------------
template
void QueueArray::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 << \" \";

9.        cout << endl;
       if (back >= front)
           for (j = 0; j < maxSize; j++)
               if ((j >= front) && (j <= back))
                   cout << dataItems[j] << \" \";
               else
                   cout << \" \";
       else
           for (j = 0; j < maxSize; j++)
               if ((j >= front) || (j <= back))
                   cout << dataItems[j] << \" \";
               else
                   cout << \" \";
       cout << endl;
   }
}
QueueArray.h
// QueueArray.h
#ifndef QUEUEARRAY_H
#define QUEUEARRAY_H
#include
#include
using namespace std;
#include \"Queue.h\"
template
class QueueArray : public Queue {
public:
   QueueArray(int maxNumber = Queue::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;

10.    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
#include
using namespace std;
#pragma warning( disable : 4290 )
//--------------------------------------------------------------------
template
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;

11. #endif
   virtual void showStructure() const = 0;
};
template
Queue::~Queue()
// Not worth having a separate class implementation file for the destuctor
{}
#endif       // #ifndef QUEUE_H