Write the definitions of the functions to overload the assignment operator and copy constructor for the class queueType. Also, write a program (in main.cpp) to test these operations.

the given classes are:

queueADT.h

//Header file: queueADT.h

#ifndef H_queueADT #define H_queueADT template class queueADT { public: virtual bool isEmptyQueue() const = 0; //Function to determine whether the queue is empty. //Postcondition: Returns true if the queue is empty, // otherwise returns false.

virtual bool isFullQueue() const = 0; //Function to determine whether the queue is full. //Postcondition: Returns true if the queue is full, // otherwise returns false.

virtual void initializeQueue() = 0; //Function to initialize the queue to an empty state. //Postcondition: The queue is empty.

virtual Type front() const = 0; //Function to return the first element of the queue. //Precondition: The queue exists and is not empty. //Postcondition: If the queue is empty, the program // terminates; otherwise, the first // element of the queue is returned.

virtual Type back() const = 0; //Function to return the last element of the queue. //Precondition: The queue exists and is not empty. //Postcondition: If the queue is empty, the program // terminates; otherwise, the last // element of the queue is returned.

virtual void addQueue(const Type& queueElement) = 0; //Function to add queueElement to the queue. //Precondition: The queue exists and is not full. //Postcondition: The queue is changed and queueElement // is added to the queue.

virtual void deleteQueue() = 0; //Function to remove the first element of the queue. //Precondition: The queue exists and is not empty. //Postcondition: The queue is changed and the first // element is removed from the queue. };

#endif

and queueAsArray.h

//Header file QueueAsArray

#ifndef H_QueueAsArray #define H_QueueAsArray #include #include

#include "queueADT.h"

using namespace std;

template class queueType: public queueADT { public: const queueType& operator=(const queueType&); //Overload the assignment operator.

bool isEmptyQueue() const; //Function to determine whether the queue is empty. //Postcondition: Returns true if the queue is empty, // otherwise returns false.

bool isFullQueue() const; //Function to determine whether the queue is full. //Postcondition: Returns true if the queue is full, // otherwise returns false.

void initializeQueue(); //Function to initialize the queue to an empty state. //Postcondition: count = 0; queueFront = 0; // queueRear = maxQueueSize 1

Type front() const; //Function to return the first element of the queue. //Precondition: The queue exists and is not empty. //Postcondition: If the queue is empty, the program // terminates; otherwise, the first // element of the queue is returned. Type back() const; //Function to return the last element of the queue. //Precondition: The queue exists and is not empty. //Postcondition: If the queue is empty, the program // terminates; otherwise, the last // element of the queue is returned.

void addQueue(const Type& queueElement); //Function to add queueElement to the queue. //Precondition: The queue exists and is not full. //Postcondition: The queue is changed and queueElement // is added to the queue.

void deleteQueue(); //Function to remove the first element of the queue. //Precondition: The queue exists and is not empty. //Postcondition: The queue is changed and the first // element is removed from the queue.

queueType(int queueSize = 100); //Constructor

queueType(const queueType& otherQueue); //Copy constructor

~queueType(); //Destructor

private: int maxQueueSize; //variable to store the maximum queue size int count; //variable to store the number of //elements in the queue int queueFront; //variable to point to the first //element of the queue int queueRear; //variable to point to the last //element of the queue Type *list; //pointer to the array that holds //the queue elements };

template bool queueType::isEmptyQueue() const { return (count == 0); } //end isEmptyQueue

template bool queueType::isFullQueue() const { return (count == maxQueueSize); } //end isFullQueue

template void queueType::initializeQueue() { queueFront = 0; queueRear = maxQueueSize - 1; count = 0; } //end initializeQueue

template Type queueType::front() const { assert(!isEmptyQueue()); return list[queueFront]; } //end front

template Type queueType::back() const { assert(!isEmptyQueue()); return list[queueRear]; } //end back

template void queueType::addQueue(const Type& newElement) { if (!isFullQueue()) { queueRear = (queueRear + 1) % maxQueueSize; //use mod //operator to advance queueRear //because the array is circular count++; list[queueRear] = newElement; } else cerr << "Cannot add to a full queue." << endl; } //end addQueue

template void queueType::deleteQueue() { if (!isEmptyQueue()) { count--; queueFront = (queueFront + 1) % maxQueueSize; //use the //mod operator to advance queueFront //because the array is circular } else cerr << "Cannot remove from an empty queue." << endl; } //end deleteQueue

//Constructor template queueType::queueType(int queueSize) { if (queueSize <= 0) { cerr << "Size of the array to hold the queue must " << "be positive." << endl; cerr << "Creating an array of size 100." << endl;

maxQueueSize = 100; } else maxQueueSize = queueSize; //set maxQueueSize to //queueSize

queueFront = 0; //initialize queueFront queueRear = maxQueueSize - 1; //initialize queueRear count = 0; list = new Type[maxQueueSize]; //create the array to //hold the queue elements } //end constructor

//Destructor template queueType::~queueType() { delete [] list; } //end destructor

//Add definition for overloaded assignment operator

//Add definition for copy constructor

#endif

make sure:

2 queues of type queueType are declared in the main

addQueue is called in main to test the operations

deletequeue is called in main to test the operations

front is called in amin to test the operations

isEmptyQueue is called in main to test operations