(C++ Data Structure) Write a program that keeps track of a speakers bureau. The program should use class ArrayBag structure to store the following data about a speaker:

Name

Telephone Number

Speaking Topic

Fee Required

The program should use an array of at least 10 structures. It should let the user enter data into the array, change the contents of any element, and display all the data stored in the array. The program should have a menu-driven user interface.

Input Validation: When the data for a new speaker is entered, be sure the user enters data for all the fields. No negative amounts should be entered for a speakers fee.

ArrayBag:

#include

using namespace std;

template

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 toVector() const = 0;

}; // end BagInterface

/////////////////////////////////////////////////////////

template

class ArrayBag : public BagInterface

{

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 toVector() const;

}; // end ArrayBag

///////////////////////////////////////////////////////////////

template

ArrayBag::ArrayBag(): itemCount(0), maxItems(DEFAULT_CAPACITY)

{

} // end default constructor

template

int ArrayBag::getCurrentSize() const

{

return itemCount;

} // end getCurrentSize

template

bool ArrayBag::isEmpty() const

{

return itemCount == 0;

} // end isEmpty

template

bool ArrayBag::add(const ItemType& newEntry)

{

bool hasRoomToAdd = (itemCount < maxItems);

if (hasRoomToAdd)

{

items[itemCount] = newEntry;

itemCount++;

} // end if

return hasRoomToAdd;

} // end add

/*

// STUB

template

bool ArrayBag::remove(const ItemType& anEntry)

{

return false; // STUB

} // end remove

*/

template

bool ArrayBag::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

void ArrayBag::clear()

{

// STUB

} // end clear

*/

template

void ArrayBag::clear()

{

itemCount = 0;

} // end clear

template

int ArrayBag::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

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

{

return getIndexOf(anEntry) > -1;

} // end contains

/* ALTERNATE 1: First version

template

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

{

return getFrequencyOf(target) > 0;

} // end contains

// ALTERNATE 2: Second version

template

bool ArrayBag::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

vector ArrayBag::toVector() const

{

vector bagContents;

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

bagContents.push_back(items[i]);

return bagContents;

} // end toVector

// private

template

int ArrayBag::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