The document provides an implementation of a queue abstract data type (ADT) using an array-based approach in C++. It includes the definition of class methods for operations such as enqueue, dequeue, and checking if the queue is empty or full, along with constructors, destructors, and a method for displaying the queue's structure. The implementation details indicate handling of edge cases like queue overflow and underflow.

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 << "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
#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 << "t";

9. 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
#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