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. HEADER FILE FOR 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

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. HEADER FILE FOR 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

Computer Networking: A Top-Down Approach (7th Edition)

7th Edition

ISBN:9780133594140

Author:James Kurose, Keith Ross

Publisher:James Kurose, Keith Ross

Chapter1: Computer Networks And The Internet

Section: Chapter Questions

Problem R1RQ: What is the difference between a host and an end system? List several different types of end...

See similar textbooks

Related questions

Question

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.

HEADER FILE FOR queueAsArray.h

//Header file QueueAsArray

#ifndef H_QueueAsArray

#define H_QueueAsArray

#include<iostream>

#include <cassert>

#include "queueADT.h"

using namespace std;

template <class Type>

class queueType: public queueADT<Type>

{

public:

const queueType<Type>& operator=(const queueType<Type>&);

//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<Type>& 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 <class Type>

bool queueType<Type>::isEmptyQueue() const

{

return (count ==0);

} //end isEmptyQueue

template <class Type>

bool queueType<Type>::isFullQueue() const

{

return (count == maxQueueSize);

} //end isFullQueue

template <class Type>

void queueType<Type>::initializeQueue()

{

queueFront = 0;

queueRear = maxQueueSize - 1;

count = 0;

} //end initializeQueue

template <class Type>

Type queueType<Type>::front() const

{

assert(!isEmptyQueue());

return list[queueFront];

} //end front

template <class Type>

Type queueType<Type>::back() const

{

assert(!isEmptyQueue());

return list[queueRear];

} //end back

template <class Type>

void queueType<Type>::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 <class Type>

void queueType<Type>::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 <class Type>

queueType<Type>::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 <class Type>

queueType<Type>::~queueType()

{

delete [] list;

} //end destructor

//Add definition for overloaded assignment operator

//Add definition for copy constructor

#endif

```cpp
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.
```

### Explanation

This code is part of a C++ header file for a queue abstract data type (ADT). It defines three virtual methods that subclasses must implement:

1. **`back()` Method**:
- **Purpose**: Returns the last element in the queue.
- **Precondition**: The queue must not be empty.
- **Postcondition**: If the queue is empty, the program will terminate. Otherwise, it returns the last element.

2. **`addQueue()` Method**:
- **Purpose**: Adds a new element (referred to as `queueElement`) to the queue.
- **Precondition**: The queue must exist and have space to add a new element (i.e., it must not be full).
- **Postcondition**: The element is added to the queue, altering its state.

3. **`deleteQueue()` Method**:
- **Purpose**: Removes the first element from the queue.
- **Precondition**: The queue must not be empty.
- **Postcondition**: The queue's state is altered by removing its first element.

```cpp
#ifndef H_queueADT
#define H_queueADT

template <class Type>
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
```

### Explanation

This code defines an abstract data type for a queue in C++ using a template class called `queueADT`. The class is designed to handle elements of any data type specified when an object is created.

1. **Guard Clauses**:
- The preprocessor directives `#ifndef` and `#define` prevent multiple inclusions of this header file.

2. **Class Template**:
- `template <class Type>` allows the definition of class templates, making the `queueADT` class adaptable for any data type.

3. **Public Methods**:
- `isEmptyQueue()`: Checks if the queue is empty. Returns `true` if empty, otherwise `false`.
- `isFullQueue()`: Checks if the queue is full. Returns `true` if full, otherwise `false`.
- `initializeQueue()`: Resets the queue to an empty state.
- `front()`: Returns the first element of the queue. If the queue is empty, the program will terminate.

These functions are declared as `virtual` and `= 0`, making them pure virtual functions, which means `queueADT` is an abstract class that cannot be instantiated on its own. Derived classes will need to provide implementations for these functions.

Expert Solution

Trending now

This is a popular solution!

Step by step

Solved in 2 steps

SEE SOLUTION Check out a sample Q&A here