Question

The function retrieveAt of the class arrayListType is written as a void function. Rewrite this function so that it is written as a value returning function, returning the required item. If the location of the item to be returned is out of range, use the assert function to terminate the program.

note: please give all code in c++

below is the class and implementation(a test program would be helpful in determining how to use it):

class arrayListType
{
public:
    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, int 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 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, int 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(int 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, int& 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, int repItem) = 0;
      //Function to replace 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(int 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(int 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:
    int *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
};

#include
#include "arrayListType.h"

using namespace std;

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

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

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

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

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

bool arrayListType::isItemAtEqual(int location, int 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);
} //end isItemAtEqual

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

void arrayListType::retrieveAt(int location, int& 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

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

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 int[maxSize];
} //end constructor

arrayListType::~arrayListType()
{
    delete [] list;
} //end destructor

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

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

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

Answer 1

I see that you have defined pure virtual functions (function declaration ending with = 0) in the class arrayListType . Hence you cannot define those function inside this class . You have to create a class and inherit this arrayListType class and define all the virtual functions there.

let tempList be the new class

class tempList : public arrayListType

{

public :

tempList(int size) : arrayListType(size)

{

// NOthing to be done in this constructor

}

/*

Put all virtual function definition here :

e.g:

void insertAt(int location, int insertItem){

// Code for insert goes here

}   

you need to do this for all the pre virtual function funtion

*/

};

As of retrieveAt() is concerned , following is the funtion definition , you need to change the function declaration in arrayListType.h accordingly :

int arrayListType::retrieveAt(int location) const
{
int retItem = 0;

assert( (location < 0) || (location >= length));
retItem = list[location];

return retItem;
} //end retrieveAt

you need to include #include<cassert> header file to use assert() function.

#include<iostream>

#include<cassert>

using namespace std;

int main()
{

tempList list1(10);

list1.insertAt(0,1);
cout<< "Value at location 0 : " << list1.retrieveAt(0) <<endl;
return 0;
}

Please comment if you are unable to do this .