Question & Answer: (C++ Data Structure) Write a program that keeps track of a speakers’ bureau. The program should use class ArrayBag structur…..

//ArrayBag.h

#ifndef ARRAYBAG_H

#define ARRAYBAG_H

#include <vector>

using namespace std;

template<class ItemType>

class BagInterface

{

public:

/** Gets the current number of entries in this bag.

@return The integer number of entries currently in the bag. */

virtual int getCurrentSize() const = 0;

/** Sees whether this bag is empty.

@return True if the bag is empty, or false if not. */

virtual bool isEmpty() const = 0;

/** Adds a new entry to this bag.

@post If successful, newEntry is stored in the bag and

the count of items in the bag has increased by 1.

@param newEntry The object to be added as a new entry.

@return True if addition was successful, or false if not. */

virtual bool add(const ItemType& newEntry) = 0;

/** Removes one occurrence of a given entry from this bag,

if possible.

@post If successful, anEntry has been removed from the bag

and the count of items in the bag has decreased by 1.

@param anEntry The entry to be removed.

@return True if removal was successful, or false if not. */

virtual bool remove(const ItemType& anEntry) = 0;

/** Removes all entries from this bag.

@post Bag contains no items, and the count of items is 0. */

virtual void clear() = 0;

/** Counts the number of times a given entry appears in bag.

@param anEntry The entry to be counted.

@return The number of times anEntry appears in the bag. */

virtual int getFrequencyOf(const ItemType& anEntry) const = 0;

/** Tests whether this bag contains a given entry.

@param anEntry The entry to locate.

@return True if bag contains anEntry, or false otherwise. */

virtual bool contains(const ItemType& anEntry) const = 0;

/** Empties and then fills a given vector with all entries that

are in this bag.

@return A vector containing all the entries in the bag. */

virtual vector<ItemType> toVector() const = 0;

}; // end BagInterface

template<class ItemType>

class ArrayBag : public BagInterface<ItemType>

{

private:

static const int DEFAULT_CAPACITY = 6; // Small size to test for a full bag

ItemType items[DEFAULT_CAPACITY]; // Array of bag items

int itemCount; // Current count of bag items

int maxItems; // Max capacity of the bag

// Returns either the index of the element in the array items that

// contains the given target or -1, if the array does not contain

// the target.

int getIndexOf(const ItemType& target) const;

public:

ArrayBag();

int getCurrentSize() const;

bool isEmpty() const;

bool add(const ItemType& newEntry);

bool remove(const ItemType& anEntry);

void clear();

bool contains(const ItemType& anEntry) const;

int getFrequencyOf(const ItemType& anEntry) const;

vector<ItemType> toVector() const;

bool operator ==(const ItemType &obj);

}; // end ArrayBag

template<class ItemType>

ArrayBag<ItemType>::ArrayBag() : itemCount(0), maxItems(DEFAULT_CAPACITY)

{

} // end default constructor

template<class ItemType>

int ArrayBag<ItemType>::getCurrentSize() const

{

return itemCount;

} // end getCurrentSize

template<class ItemType>

bool ArrayBag<ItemType>::isEmpty() const

{

return itemCount == 0;

} // end isEmpty

template<class ItemType>

bool ArrayBag<ItemType>::add(const ItemType& newEntry)

{

bool hasRoomToAdd = (itemCount < maxItems);

if (hasRoomToAdd)

{

items[itemCount] = newEntry;

itemCount++;

} // end if

return hasRoomToAdd;

} // end add

/*

// STUB

template<class ItemType>

bool ArrayBag<ItemType>::remove(const ItemType& anEntry)

{

return false; // STUB

} // end remove

*/

template<class ItemType>

bool ArrayBag<ItemType>::remove(const ItemType& anEntry)

{

int locatedIndex = getIndexOf(anEntry);

bool canRemoveItem = !isEmpty() && (locatedIndex > -1);

if (canRemoveItem)

{

itemCount–;

items[locatedIndex] = items[itemCount];

} // end if

return canRemoveItem;

} // end remove

/*

// STUB

template<class ItemType>

void ArrayBag<ItemType>::clear()

{

// STUB

} // end clear

*/

template<class ItemType>

void ArrayBag<ItemType>::clear()

{

itemCount = 0;

} // end clear

template<class ItemType>

int ArrayBag<ItemType>::getFrequencyOf(const ItemType& anEntry) const

{

int frequency = 0;

int curIndex = 0; // Current array index

while (curIndex < itemCount)

{

//if (items[curIndex] == anEntry)

{

frequency++;

} // end if

curIndex++; // Increment to next entry

} // end while

return frequency;

} // end getFrequencyOf

template<class ItemType>

bool ArrayBag<ItemType>::contains(const ItemType& anEntry) const

{

return getIndexOf(anEntry) > -1;

} // end contains

/* ALTERNATE 1: First version

template<class ItemType>

bool ArrayBag<ItemType>::contains(const ItemType& target) const

{

return getFrequencyOf(target) > 0;

} // end contains

// ALTERNATE 2: Second version

template<class ItemType>

bool ArrayBag<ItemType>::contains(const ItemType& anEntry) const

{

bool found = false;

int curIndex = 0; // Current array index

while (!found && (curIndex < itemCount))

{

if (anEntry == items[curIndex])

{

found = true;

} // end if

curIndex++; // Increment to next entry

} // end while

return found;

} // end contains

*/

template<class ItemType>

vector<ItemType> ArrayBag<ItemType>::toVector() const

{

vector<ItemType> bagContents;

for (int i = 0; i < itemCount; i++)

bagContents.push_back(items[i]);

return bagContents;

} // end toVector

// private

template<class ItemType>

int ArrayBag<ItemType>::getIndexOf(const ItemType& target) const

{

bool found = false;

int result = -1;

int searchIndex = 0;

// If the bag is empty, itemCount is zero, so loop is skipped

//while (!found && (searchIndex < itemCount))

//{

// //if (items[searchIndex] == target)

// {

// found = true;

// result = searchIndex;

// }

// else

// {

// searchIndex++;

// } // end if

//} // end while

return result;

} // end getIndexOf

template<class ItemType>

bool ArrayBag<ItemType>:: operator ==(const ItemType &obj)

{

return (this->items[0] == obj );

}

#endif // !ARRAYBAG_H

//speaker.cpp

#include<iostream>

#include<string>

#include “ArrayBag.h”

using namespace std;

struct Speaker

{

string name;

string telephone;

string topic;

double fee;

};

int main()

{

ArrayBag<Speaker> speakersArray;

Speaker sp[10];

for (int i = 0; i < 10; i++)

{

int option;

cout << “what you want to do Please select 1, 2 or 3:” << endl;

cout << ” 1.Enter Data 2.Change content 3.Display” << endl;

string name, telephone, topic;

double fee;

vector<Speaker> v;

string newField; //Use for new name telephone and topic

double newFee; //use to enter new fee from user

cin >> option;

Speaker s;

switch (option)

{

case 1:

while (true)

{

cout << “Please enter Name of Speaker:”;

cin >> name;

if (name.size() > 0)

break;

else

cout << “Please enter a valid Name of Speaker:”;

}

cout << “Please enter telephone number of Speaker:”;

cin >> telephone;

cout << “Please enter topic of Speaker:”;

cin >> topic;

while (true)

{

cout << “Please enter fee of Speaker:”;

cin >> fee;

if (fee > 0)

break;

else

cout << “Please enter a right positive number as fee of Speaker:”;

}

sp[i].telephone = telephone;

sp[i].name = name;

sp[i].topic = topic;

sp[i].fee = fee;

speakersArray.add(sp[i]);

break;

case 2:

cout << “which element you want to change enter index starting from 0:”;

int i;

cin >> i;

cout << “what you want to change:” << endl;

cout << “1: name 2: telephone 3:topic 4:fee” << endl;

int fieldTochange;

cin >> fieldTochange;

v = speakersArray.toVector();

s = v.at(i);

switch (fieldTochange)

{

case 1:

cout << “Enter new name ” << endl;

cin >> newField;

s.name = newField;

case 2:

cout << “Enter new telephone ” << endl;

cin >> newField;

s.telephone = newField;

case 3:

cout << “Enter new topic ” << endl;

cin >> newField;

s.topic = newField;

case 4:

cout << “Enter new fee ” << endl;

cin >> newFee;

s.fee = newFee;

default:

cout << “enter valid input” << endl;

break;

}

break;

case 3:

v = speakersArray.toVector();

for (auto it = v.begin(); it != v.end(); it++)

{

Speaker s = *it;

cout << “name ” << s.name << ” telephone ” << s.telephone << ” topic ” << s.topic << ” fee ” << s.fee << endl;

}

break;

default:

cout << “please enter a valid option” << endl;

break;

}

}

}

//output: