The attached code contains a solution to programming exercises 1 on page 259 data structures using c++ 2nd ed.

Modify the attached solution by replacing the array lists with vectors. c++

source cpp.

#include #include #include #include #include #include "arrayListType.h" using namespace std;

string readName(); int readVotes(const string& name); string trim(const string& original); int compTotalVotes(const arrayListType& votes); void compPercentVotes(const arrayListType& votes, arrayListType& percents); int findWinner(const arrayListType& votes); void writeCandidates(ostream& outs, const arrayListType& names, const arrayListType& votes);

int main() { try { const int n_candidates = 5; arrayListType names(n_candidates); arrayListType votes(n_candidates); for (int index = 0; index < n_candidates; index++) { string candidate_name; do { candidate_name = readName(); } while (names.seqSearch(candidate_name) != -1); names.insertAt(index, candidate_name); int candidate_votes = readVotes(candidate_name); votes.insertAt(index, candidate_votes); cin.get(); } writeCandidates(cout, names, votes); } catch (exception ex) { cerr << ex.what() << endl; }

system("pause"); return 0; } void writeCandidates(ostream& outs, const arrayListType& names, const arrayListType& votes) { const int filler = 5; arrayListType percents(names.listSize()); int total_votes = compTotalVotes(votes); int fieldWidthVotes = max(string("Votes Received").length(), to_string(total_votes).length()) + filler; int fieldWidthPercents = max(string("% of Total Votes").length(), to_string(100.00).length()) + filler; compPercentVotes(votes, percents); int winner_index = findWinner(votes);

int fieldWidthName = string("Candidate").length(); for (int index = 0; index < names.listSize(); index++) { string candidate_name; names.retrieveAt(index, candidate_name); if (candidate_name.length() > fieldWidthName) fieldWidthName = candidate_name.length(); } outs << setw(fieldWidthName) << left << "Candidate" << setw(fieldWidthVotes) << right << "Votes Received" << setw(fieldWidthPercents) << right << "% of Total Votes" << endl; for (int index = 0; index < names.listSize(); index++) { string candidate_name; names.retrieveAt(index, candidate_name); if (candidate_name.length() > fieldWidthName) fieldWidthName = candidate_name.length(); int candidate_votes; votes.retrieveAt(index, candidate_votes); float candidate_percents; percents.retrieveAt(index, candidate_percents); outs << setw(fieldWidthName) << left << candidate_name << setw(fieldWidthVotes) << right << candidate_votes << setw(fieldWidthPercents) << right << fixed << setprecision(2) << 100 * candidate_percents << endl; } outs << setw(fieldWidthName) << left << "Total" << setw(fieldWidthVotes) << right << total_votes << endl; string winner_name; names.retrieveAt(winner_index, winner_name); outs << "The winner of the election is " << winner_name << endl; } void compPercentVotes(const arrayListType& votes, arrayListType& percents) { float total_votes = static_cast(compTotalVotes(votes)); for (int index = 0; index < votes.listSize(); index++) { int candidate_votes; votes.retrieveAt(index, candidate_votes); float percent = total_votes > 0 ? candidate_votes / total_votes : 0.0F; percents.insertAt(index, percent); } } int compTotalVotes(const arrayListType& votes) { int total_votes = 0; for (int index = 0; index < votes.listSize(); index++) { int candidate_votes; votes.retrieveAt(index, candidate_votes); total_votes += candidate_votes; } return total_votes; } int findWinner(const arrayListType& votes) { int winner_index = 0; int winner_votes; votes.retrieveAt(winner_index, winner_votes); for (int index = 1; index < votes.listSize(); index++) { int candidate_votes; votes.retrieveAt(index, candidate_votes); if (candidate_votes > winner_votes) { winner_index = index; winner_votes = candidate_votes; } } return winner_index; } int readVotes(const string& name) { int votes; do { cout << "Enter " << name << "'s votes: "; cin >> votes; if (!cin.good()) { cin.clear(); cin.ignore(numeric_limits::max(), ' '); votes = -1; } } while (votes < 0); return votes; } string readName() { string name; do { cout << "Enter candidate's name: "; getline(cin, name, ' '); name = trim(name); } while (name.length() == 0); return name; } string trim(const string& original) { int right_index = original.length() - 1; int left_index = 0; while (left_index <= right_index && isspace(original[left_index])) left_index++; while (left_index <= right_index && isspace(original[right_index])) right_index--; unsigned length = right_index - left_index + 1; return original.substr(left_index, length); }

arrayListType.h

#ifndef H_arrayListType #define H_arrayListType

//*********************************************************** // Author: D.S. Malik // // This class specifies the members to implement the basic // properties of array-based lists. //***********************************************************

#include #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 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 the item is the same //as the item in the list at the position specified by //Postcondition: Returns true if the list[location] // is the same as the item; otherwise, // returns false. void insertAt(int location, const elemType& insertItem); //Function to insert an item in the list at the //position specified by location. The item to be inserted //is passed as a parameter to the function. //Postcondition: Starting at location, the elements of the // list are shifted down, list[location] = insertItem;, // and length++;. If the list is full or location is // out of range, an appropriate message is displayed. void insertEnd(const elemType& insertItem); //Function to insert an item at the end of the list. //The parameter insertItem specifies the item to be inserted. //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. void replaceAt(int location, const elemType& repItem); //Function to replace the elements in the list at the //position specified by location. The item to be replaced //is specified by the parameter repItem. //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; int seqSearch(const elemType& item) const; //Function to search the list for a given item. //Postcondition: If the item is found, returns the location // in the array where the item is found; otherwise, // returns -1. void insert(const elemType& insertItem); //Function to insert the item specified by the parameter //insertItem at the end of the list. However, first the //list is searched to see whether the item to be inserted //is already in the list. //Postcondition: list[length] = insertItem and length++ // If the item is already in the list or the list // is full, an appropriate message is displayed. void remove(const elemType& removeItem); //Function to remove an item from the list. The parameter //removeItem specifies the item to be removed. //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

~arrayListType(); //destructor //Deallocates the memory occupied by the array.

protected: elemType *list; //array to hold the list elements int length; //to store the length of the list int maxSize; //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 { return (list[location] == item); } template void arrayListType::insertAt(int location, const elemType& insertItem) { if (location < 0 || location >= maxSize) cerr << "The position of the item to be inserted is out of range" << endl; else if (length >= maxSize) //list is full cerr << "Cannot insert in a full list" << endl; else { for (int i = length; i > location; i--) list[i] = list[i - 1]; //move the elements down

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

length++; //increment the length } } //end insertAt template void arrayListType::insertEnd(const elemType& insertItem) {

if (length >= maxSize) //the list is full cerr << "Cannot insert in a full list" << endl; else { list[length] = insertItem; //insert the item at the end length++; //increment the length } } //end insertEnd template void arrayListType::removeAt(int location) { if (location < 0 || location >= length) cerr << "The location of the item to be removed is out of range" << endl; else { list[location] = list[length - 1]; length--; } } //end removeAt template void arrayListType::retrieveAt(int location, elemType& retItem) const { if (location < 0 || location >= length) cerr << "The location of the item to be retrieved is out of range." << endl; else retItem = list[location]; } //end retrieveAt template void arrayListType::replaceAt(int location, const elemType& repItem) { if (location < 0 || location >= length) cerr << "The location of the item to be replaced is out of range." << endl; else list[location] = repItem;

} //end replaceAt template void arrayListType::clearList() { length = 0; } //end clearList template int arrayListType::seqSearch(const elemType& item) const { int loc; bool found = false;

for (loc = 0; loc < length; loc++) if (list[loc] == item) { found = true; break; }

if (found) return loc; else return -1; } //end seqSearch template void arrayListType::insert(const elemType& insertItem) { int loc;

if (length == 0) //list is empty list[length++] = insertItem; //insert the item and //increment the length else if (length == maxSize) cerr << "Cannot insert in a full list." << endl; else { loc = seqSearch(insertItem);

if (loc == -1) //the item to be inserted //does not exist in the list list[length++] = insertItem; else cerr << "the item to be inserted is already in the list. No duplicates are allowed." << endl; } } //end insert template void arrayListType::remove(const elemType& removeItem) { int loc;

if (length == 0) cerr << "Cannot delete from an empty list." << endl; else { loc = seqSearch(removeItem); if (loc != -1) removeAt(loc); else cout << "The item to be deleted is not in the list." << endl; } } //end remove template arrayListType::arrayListType(int size) { if (size < 0) { cerr << "The array size must be positive. Creating an array of size 100. " << endl;

maxSize = 100; } else maxSize = size;

length = 0;

list = new elemType[maxSize]; assert(list != NULL); } template arrayListType::~arrayListType() { delete [] list; } template arrayListType::arrayListType(const arrayListType& otherList) { maxSize = otherList.maxSize; length = otherList.length; list = new elemType[maxSize]; //create the array assert(list != NULL); //terminate if unable to allocate //memory space

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]; //create the array assert(list != NULL); //if unable to allocate memory //space, terminate the program for (int i = 0; i < length; i++) list[i] = otherList.list[i]; } return *this; } #endif