In c++ Modify the set class (below) to make it a template. Revise your test program(also below) to show that your template works with a data type that is not int for the elements of the set. Use the template versions for the unorderedArrayListType and arrayListType classes.

//template arrayListType

#ifndef H_arrayListType #define H_arrayListType

#include using namespace std;

template class arrayListType { public: const arrayListType& operator=(const arrayListType&); //Overloads the assignment operator

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

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

int listSize() const; //Function to determine the number of elements in //the list. //Postcondition: Returns the value of length.

int maxListSize() const; //Function to determine the maximum size of the list //Postcondition: Returns the value of maxSize.

void print() const; //Function to output the elements of the list //Postcondition: Elements of the list are output on the // standard output device.

bool isItemAtEqual(int location, const elemType& item) const; //Function to determine whether item is the same as //the item in the list at the position specified //by location. //Postcondition: Returns true if the list[location] // is the same as item; otherwise, // returns false. // If location is out of range, an // appropriate message is displayed.

virtual void insertAt(int location, const elemType& insertItem) = 0; //Function to insert insertItem in the list at the //position specified by location. //Note that this is an abstract function. //Postcondition: Starting at location, the elements of // the list are shifted down, // list[location] = insertItem; length++; // If the list is full or location is out of // range, an appropriate message is displayed.

virtual void insertEnd(const elemType& insertItem) = 0; //Function to insert insertItem an item at the end of //the list. Note that this is an abstract function. //Postcondition: list[length] = insertItem; and length++; // If the list is full, an appropriate // message is displayed.

void removeAt(int location); //Function to remove the item from the list at the //position specified by location //Postcondition: The list element at list[location] is // removed and length is decremented by 1. // If location is out of range, an // appropriate message is displayed.

void retrieveAt(int location, elemType& retItem) const; //Function to retrieve the element from the list at the //position specified by location //Postcondition: retItem = list[location] // If location is out of range, an // appropriate message is displayed.

virtual void replaceAt(int location, const elemType& repItem) = 0; //Function to replace repItem the elements in the list //at the position specified by location. //Note that this is an abstract function. //Postcondition: list[location] = repItem // If location is out of range, an // appropriate message is displayed.

void clearList(); //Function to remove all the elements from the list //After this operation, the size of the list is zero. //Postcondition: length = 0;

virtual int seqSearch(const elemType& searchItem) const = 0; //Function to search the list for searchItem. //Note that this is an abstract function. //Postcondition: If the item is found, returns the // location in the array where the item is // found; otherwise, returns -1.

virtual void remove(const elemType& removeItem) = 0; //Function to remove removeItem from the list. //Note that this is an abstract function. //Postcondition: If removeItem is found in the list, // it is removed from the list and length // is decremented by one.

arrayListType(int size = 100); //Constructor //Creates an array of the size specified by the //parameter size. The default array size is 100. //Postcondition: The list points to the array, length = 0, // and maxSize = size;

arrayListType (const arrayListType& otherList); //Copy constructor

virtual ~arrayListType(); //Destructor //Deallocate the memory occupied by the array.

protected: elemType *list; //array to hold the list elements int length; //variable to store the length of the list int maxSize; //variable to store the maximum //size of the list };

template bool arrayListType::isEmpty() const { return (length == 0); }

template bool arrayListType::isFull() const { return (length == maxSize); }

template int arrayListType::listSize() const { return length; }

template int arrayListType::maxListSize() const { return maxSize; }

template void arrayListType::print() const { for (int i = 0; i < length; i++) cout << list[i] << " "; cout << endl; }

template bool arrayListType::isItemAtEqual(int location, const elemType& item) const { if (location < 0 || location >= length) { cout << "The location of the item to be removed " << "is out of range." << endl;

return false; } else return (list[location] == item); }

template void arrayListType::removeAt(int location) { if (location < 0 || location >= length) cout << "The location of the item to be removed " << "is out of range." << endl; else { for (int i = location; i < length - 1; i++) list[i] = list[i + 1];

length--; } } //end removeAt

template void arrayListType::retrieveAt(int location, elemType& retItem) const { if (location < 0 || location >= length) cout << "The location of the item to be retrieved is " << "out of range" << endl; else retItem = list[location]; } //end retrieveAt

template void arrayListType::clearList() { length = 0; } //end clearList

template arrayListType::arrayListType(int size) { if (size <= 0) { cout << "The array size must be positive. Creating " << "an array of the size 100. " << endl;

maxSize = 100; } else maxSize = size;

length = 0;

list = new elemType[maxSize]; }

template arrayListType::~arrayListType() { delete [] list; }

template arrayListType::arrayListType(const arrayListType& otherList) { maxSize = otherList.maxSize; length = otherList.length;

list = new elemType[maxSize]; //create the array

for (int j = 0; j < length; j++) //copy otherList list [j] = otherList.list[j]; }//end copy constructor

template const arrayListType& arrayListType::operator= (const arrayListType& otherList) { if (this != &otherList) //avoid self-assignment { delete [] list; maxSize = otherList.maxSize; length = otherList.length; list = new elemType[maxSize];

for (int i = 0; i < length; i++) list[i] = otherList.list[i]; } return *this; }

#endif

// unorderedArrayListType template

#ifndef H_unorderedArrayListType #define H_unorderedArrayListType

#include "arrayListType.h"

template class unorderedArrayListType: public arrayListType { public: void insertAt(int location, const elemType& insertItem); void insertEnd(const elemType& insertItem); void replaceAt(int location, const elemType& repItem); int seqSearch(const elemType& searchItem) const; void remove(const elemType& removeItem);

unorderedArrayListType(int size = 100); //Constructor

};

template void unorderedArrayListType::insertAt(int location, const elemType& insertItem) { if (location < 0 || location >= this->maxSize) cout << "The position of the item to be inserted " << "is out of range." << endl; else if (this->length >= this->maxSize) //list is full cout << "Cannot insert in a full list" << endl; else { for (int i = this->length; i > location; i--) this->list[i] = this->list[i - 1]; //move the elements down

this->list[location] = insertItem; //insert the item at //the specified position

this->length++; //increment the length } } //end insertAt

template void unorderedArrayListType::insertEnd (const elemType& insertItem) { if (this->length >= this->maxSize) //the list is full cout << "Cannot insert in a full list." << endl; else { this->list[this->length] = insertItem; //insert the item at the end this->length++; //increment the length } } //end insertEnd

template int unorderedArrayListType::seqSearch (const elemType& searchItem) const { int loc; bool found = false;

for (loc = 0; loc < this->length; loc++) if (this->list[loc] == searchItem) { found = true; break; }

if (found) return loc; else return -1; } //end seqSearch

template void unorderedArrayListType::remove (const elemType& removeItem) { int loc;

if (this->length == 0) cout << "Cannot delete from an empty list." << endl; else { loc = seqSearch(removeItem);

if (loc != -1) this->removeAt(loc); else cout << "The item to be deleted is not in the list." << endl; } } //end remove

template void unorderedArrayListType::replaceAt(int location, const elemType& repItem) { if (location < 0 || location >= this->length) cout << "The location of the item to be " << "replaced is out of range." << endl; else this->list[location] = repItem; } //end replaceAt

template unorderedArrayListType::unorderedArrayListType(int size) : arrayListType(size) { } #endif

//unorderedSetType

#ifndef UNORDEREDSETTYPE_H_INCLUDED #define UNORDEREDSETTYPE_H_INCLUDED

#include "unorderedArrayListType.h"

using namespace std; class unorderedSetType: public unorderedArrayListType { private:

void insertAt(int location, int insertItem);// inserts item in list // postcondition item is not in list already

public:

void insertEnd(int insertItem); // inserts item in list at the end // as specified by the user postcondition location must be valid and is not // already in the list

void setUnion(unorderedSetType intList, unorderedSetType intList2);// combines the first two list into one // to create the third list postcondition duplicate numbers will ignored

void getIntersection(unorderedSetType intList, unorderedSetType intList2);// sets fourth list // by inserting object where specified

void replaceAt(int searchItem, int repItem);// checks list and replaces where specified by user //

unorderedSetType(int size = 100);//constructor

};

#endif UNORDEREDSETTYPE_H_INCLUDED

#include #include "unorderedSetType.h"

using namespace std;

void unorderedSetType::insertAt(int location, int insertItem) { insertEnd(insertItem); }

void unorderedSetType::insertEnd(int insertItem) { int searchItem = insertItem; int loc; loc = unorderedArrayListType::seqSearch(searchItem);

if (length >= maxSize) //the list is full { cout << "Cannot insert in a full list." << endl; } else if(loc >= 0) { cout << list[loc] << " is already in list. Ignoring request." << endl << endl; } else { list[length] = insertItem; //insert the item at the end length++; //increment the length } }

void unorderedSetType::replaceAt(int searchItem, int repItem) { int loc; loc = unorderedArrayListType::seqSearch(searchItem);

if (loc < 0 || loc >= length) { cout << "The location of the item to be replaced is out of range." << endl; } else if(unorderedArrayListType::seqSearch(repItem) >= 0) { cout << list[unorderedArrayListType::seqSearch(repItem)] << " is already in list. Ignoring request." << endl << endl; } else { list[loc] = repItem; } }

void unorderedSetType::setUnion(unorderedSetType intList, unorderedSetType intList2) { unorderedSetType testUnion; int look;

for (int i = 0; i < 8; i++) { look = intList.list[i]; testUnion.insertEnd(look); look = intList2.list[i]; testUnion.insertEnd(look); }

cout << "Third list (union): "; testUnion.print(); cout << endl; }

void unorderedSetType::getIntersection(unorderedSetType intList, unorderedSetType intList2) { unorderedSetType testIntersection; int look;

for (int i = 0; i < 8; i++) { look = intList.list[i]; if(intList2.seqSearch(look) >= 0) { testIntersection.insertEnd(look); } }

cout << "Fourth list (intersection): "; testIntersection.print(); cout << endl; }

unorderedSetType::unorderedSetType(int size) { } //end constructor

#include #include "unorderedSetType.h" #include "unorderedArrayListType.h" #include "arrayListType.h"

using namespace std;

int main() { unorderedSetType intList(25); unorderedSetType intList2(25); unorderedSetType testUnion(50); unorderedSetType testIntersection(25);

int number, repItem, searchItem;

cout << "Enter 8 integers: ";

for (int count = 0; count < 8; count++) { cin >> number; intList.insertEnd(number); }

number = 0;

cout << "Enter 8 integers (2nd set): ";

for (int count = 0; count < 8; count++) { cin >> number; intList2.insertEnd(number); }

cout << endl; cout << "intList: "; intList.print(); cout << endl;

cout << "intList2: "; intList2.print(); cout << endl;

cout << "Attempting to run a union function on lists 1 and 2..." << endl; testUnion.setUnion(intList, intList2);

cout << "Attempting to run an intersection function on lists 1 and 2..." << endl; testIntersection.getIntersection(intList, intList2);

cout << "Enter the number to be replaced (list 1): "; intList.print(); cout << endl; cin >> searchItem; cout << endl << "Enter the number you would like to replace '" << searchItem << "' with in list 1: "; cin >> repItem; cout << endl;

intList.replaceAt(searchItem, repItem);

cout << "List 1, following replacement function: "; intList.print(); cout << endl;

return 0; }