Questions:

- implement the ListArray ADT [the declaration is given in ListArray.h]

- implement the following operations:

- constructor, copy constructor, assignment operator, destructor; (30 pts)

- gotoBeginning, gotoEnd, gotoNext, gotoPrior, getCursor; (20 pts)

GIVEN CODE:

config.h:

/** * List class (Lab 3/Lab 4) configuration file. * Activate test #N by defining the corresponding LAB3_TESTN to have the value 1. * * Because you will copy the List class code to your ordered list directory, having * two "config.h" files presented the risk of accidentally replacing the one in the * ordered list directory. So the two configuration files are combined for labs 3 and 4. * * NOTE!!! There was an error in the printed book. TEST1 shows up twice in the book. * The basic List implementation uses TEST1 as described below, then exercise 2 * is activated by TEST2 */

#define LAB3_TEST1 0 // 0 => test with char, 1 => test with int #define LAB3_TEST2 0 // Prog exercise 2: moveToNth #define LAB3_TEST3 0 // Prog exercise 3: find

/** * Ordered list class tests. */ #define LAB4_TEST1 0 // merge: programming exercise 2 #define LAB4_TEST2 0 // subset: programming exercise 3

ListArray.h:

//-------------------------------------------------------------------- // // Laboratory 3 ListArray.h // **Instructor's Solution** // Class declaration for the array implementation of the List ADT // //--------------------------------------------------------------------

#ifndef LISTARRAY_H #define LISTARRAY_H

#include #include

using namespace std;

template < typename DataType > class List { public:

static const int MAX_LIST_SIZE = 10; // Default maximum list size

// Constructors List ( int maxNumber = MAX_LIST_SIZE ); // Default constructor List ( const List& source ); // Copy constructor // Overloaded assignment operator List& operator= ( const List& source );

// Destructor virtual ~List ();

// List manipulation operations virtual void insert ( const DataType& newDataItem ) // Insert after cursor throw ( logic_error ); void remove () throw ( logic_error ); // Remove data item virtual void replace ( const DataType& newDataItem ) // Replace data item throw ( logic_error ); void clear (); // Clear list

// List status operations bool isEmpty () const; // List is empty bool isFull () const; // List is full

// List iteration operations void gotoBeginning () // Go to beginning throw ( logic_error ); void gotoEnd () // Go to end throw ( logic_error ); bool gotoNext () // Go to next data item throw ( logic_error ); bool gotoPrior () // Go to prior data item throw ( logic_error ); DataType getCursor () const throw ( logic_error ); // Return data item

// Output the list structure -- used in testing/debugging virtual void showStructure () const;

// In-lab operations void moveToNth ( int n ) // Move data item to pos. n throw ( logic_error ); bool find ( const DataType& searchDataItem ) // Find data item throw ( logic_error );

protected:

// Data members int maxSize, size, // Actual number of data item in the list cursor; // Cursor array index DataType *dataItems; // Array containing the list data item };

#endif

ListArray.cpp:

#include "ListArray.h"

template < typename DataType > List::List ( int maxNumber ) { }

template < typename DataType > List::List ( const List& source ) { } template < typename DataType > List& List::operator= ( const List& source ) { return *this; }

template < typename DataType > List::~List () { }

template < typename DataType > void List::insert ( const DataType& newDataItem ) throw ( logic_error ) { }

template < typename DataType > void List::remove () throw ( logic_error ) { }

template < typename DataType > void List::replace ( const DataType& newDataItem ) throw ( logic_error ) { }

template < typename DataType > void List::clear () { }

template < typename DataType > bool List::isEmpty () const { return false; }

template < typename DataType > bool List::isFull () const { return false; }

template < typename DataType > void List::gotoBeginning () throw ( logic_error ) { }

template < typename DataType > void List::gotoEnd () throw ( logic_error ) { }

template < typename DataType > bool List::gotoNext () throw ( logic_error ) { return false; }

template < typename DataType > bool List::gotoPrior () throw ( logic_error ) { return false; }

template < typename DataType > DataType List::getCursor () const throw ( logic_error ) { DataType t; return t; }

#include "show3.cpp"

template < typename DataType > void List::moveToNth ( int n ) throw ( logic_error ) { }

template < typename DataType > bool List::find ( const DataType& searchDataItem ) throw ( logic_error ) { return false; }

show3.cpp:

//-------------------------------------------------------------------- // // Laboratory 3 show3.cpp // // Array implementation of the showStructure operation for the // List ADT // //-------------------------------------------------------------------- #include "ListArray.h"

template void List:: showStructure () const

// outputs the data items in a list. if the list is empty, outputs // "empty list". this operation is intended for testing/debugging // purposes only.

{ int j; // loop counter

if ( size == 0 ) cout << "empty list" << endl; // The Ordered List code blows up below. Since this is just debugging // code, we check for whether the OrderedList is defined, and if so, // print out the key value. If not, we try printing out the entire item. // Note: This assumes that you have used the double-inclusion protection // in your OrderedList.cpp file by doing a "#ifndef ORDEREDLIST_CPP", etc. // If not, you will need to comment out the code in the section under // the "else", otherwise the compiler will go crazy in lab 4. // The alternative is to overload operator<< for all data types used in // the ordered list. else { cout << "size = " << size << " cursor = " << cursor << endl; for ( j = 0 ; j < maxSize ; j++ ) cout << j << "\t"; cout << endl; for ( j = 0 ; j < size ; j++ ) { if( j == cursor ) { cout << "["; cout << dataItems[j] #ifdef ORDEREDLIST_CPP .getKey() #endif ; cout << "]"; cout << "\t"; } else cout << dataItems[j] #ifdef ORDEREDLIST_CPP .getKey() #endif << "\t"; } cout << endl; } }