main.cpp


#include <iostream>

using namespace std;

#include "ListArray.cpp"
#include "config.h"

void print_help();
void showTwoLists(List<char> list1, List<char> list2);    // Displays two lists that are supposedly equivalent.

int main()
{

#if   LAB3_TEST1
    List<int> testList(8);    // Test list to test with ints
    List<int> copyList(testList); // Used to test copy constructor
    List<int> assignList;     // Used to test assignment operator
    int testData;             // List data item
#else
    List<char> testList(8);   // Test list to test with chars
    List<char> copyList(testList); // Used to test copy constructor
    List<char> assignList;     // Used to test assignment operator
    char testData;            // List data item
#endif
    int n;                    // Position within list
    char cmd;                 // Input command

    print_help();

    do
    {
        testList.showStructure();                     // Output list

        cout << endl << "Command: ";                  // Read command
        cin >> cmd;
        if ( cmd == '+' || cmd == '=' || cmd == '?' )
           cin >> testData;
        else if ( cmd == 'M' || cmd == 'm' )
           cin >> n;

        switch ( cmd )
        {
          case 'H' : case 'h':
               print_help();
               break;

          case '+' :                                  // insert
               cout << "Insert " << testData << endl;
               try
               {
                  testList.insert(testData);
               }
               catch (logic_error &e)
               {
                  cerr << "EXCEPTION: A logic error occurred in the insert function.";
               }
               break;

          case '-' :                                  // remove
               cout << "Remove the data item marked by the cursor"
                    << endl;
               try
               {
                  testList.remove();
               }
               catch (logic_error &e)
               {
                  cerr << "EXCEPTION: A logic error occurred in the remove function.";
               }
               break;

          case '=' :                                  // replace
               cout << "Replace the data item marked by the cursor "
                    << "with " << testData << endl;
               try
               {
                  testList.replace(testData);
               }
               catch (logic_error &e)
               {
                  cerr << "EXCEPTION: A logic error occurred in the replace function.";
               }
               break;

          case '@' :                                  // getCursor
               try
               {
                  cout << "Data item marked by the cursor is "
                       << testList.getCursor() << endl;
               }
               catch (logic_error &e)
               {
                  cerr << "EXCEPTION: A logic error occurred in the getCursor function.";
               }
               break;

          case '<' :                                  // gotoBeginning
               cout << "Go to the beginning of the list" << endl;
               try
               {
                  testList.gotoBeginning();
               }
               catch (logic_error &e)
               {
                  cerr << "EXCEPTION: A logic error occurred in the gotoBeginning function.";
               }
               break;

          case '>' :                                  // gotoEnd
               cout << "Go to the end of the list" << endl;
               try
               {
                  testList.gotoEnd();
               }
               catch (logic_error &e)
               {
                  cerr << "EXCEPTION: A logic error occurred in the gotoEnd function.";
               }
               break;

          case 'N' : case 'n' :                       // gotoNext
               try
               {
                  if ( testList.gotoNext() )
                     cout << "Go to the next data item" << endl;
                  else
                     cout << "Failed -- either at the end of the list "
                          << "or the list is empty" << endl;
               }
               catch (logic_error &e)
               {
                  cerr << "EXCEPTION: A logic error occurred in the gotoNext function.";
               }
               break;

          case 'P' : case 'p' :                       // gotoPrior
               try
               {
                  if ( testList.gotoPrior() )
                     cout << "Go to the prior data item" << endl;
                  else
                     cout << "Failed -- either at the beginning of the "
                          << "list or the list is empty" << endl;
               }
               catch (logic_error &e)
               {
                  cerr << "EXCEPTION: A logic error occurred in the gotoPrior function.";
               }
               break;

          case 'C' : case 'c' :                       // clear
               cout << "Clear the list" << endl;
               testList.clear();
               break;

          case 'E' : case 'e' :                       // isEmpty
               if ( testList.isEmpty() )
                  cout << "List is empty" << endl;
               else
                  cout << "List is NOT empty" << endl;
               break;

          case 'F' : case 'f' :                       // isFull
               if ( testList.isFull() )
                  cout << "List is full" << endl;
               else
                  cout << "List is NOT full" << endl;
               break;

          case '!' :
       //                                                      showTwoLists(copyList, testList);
       break;
          case '#' :
       assignList.insert('x');
       assignList = testList;
       //                                                     showTwoLists(assignList, testList);
       break;

#if   LAB3_TEST2
          case 'M' : case 'm' :                   // In-lab Exercise 2
               cout << "Move the data item marked by the cursor to "
                    << "posititon " << n << endl;
               try
               {
                  testList.moveToNth(n);
               }
               catch (logic_error &e)
               {
                  cerr << "EXCEPTION: A logic error occurred in the moveToNth function.";
               }
               break;
#endif // LAB3_TEST1

#if   LAB3_TEST3
          case '?' :                              // In-lab Exercise 3
               try
               {
               if ( testList.find(testData) )
                  cout << "Found" << endl;
               else
                  cout << "NOT found" << endl;
               }
               catch (logic_error &e)
               {
                  cerr << "EXCEPTION: A logic error occurred in the find function.";
               }
               break;
#endif // LAB3_TEST3

          case 'Q' : case 'q' :                   // Quit test program
               break;

          default :                               // Invalid command
               cout << "Inactive or invalid command" << endl;
        }
    }
    while ( cin && cmd != 'Q' && cmd != 'q' );

    if( !cin ) {
   cout << "Input error" << endl;
    }

    return 0;
}

void showTwoLists(List<char> list1, List<char> list2) {
    // Variables should match, but dynamic memory buffer must be different
    cout << "Look at the two lists below and decide whether they are equivalent" << endl;
    cout << "List 1: ";
    list1.showStructure();
    cout << "List 2: ";
    list2.showStructure();
    cout << endl;
}

void print_help()
{
    cout << endl << "Commands:" << endl;
    cout << " H   : Help (displays this message)" << endl;
    cout << " +x : Insert x after the cursor" << endl;
    cout << " -   : Remove the data item marked by the cursor" << endl;
    cout << " =x : Replace the data item marked by the cursor with x"
         << endl;
    cout << " @   : Display the data item marked by the cursor" << endl;
    cout << " <   : Go to the beginning of the list" << endl;
    cout << " >   : Go to the end of the list" << endl;
    cout << " N   : Go to the next data item" << endl;
    cout << " P   : Go to the prior data item" << endl;
    cout << " C   : Clear the list" << endl;
    cout << " E   : Empty list?" << endl;
    cout << " F   : Full list?" << endl;
    cout << " !   : Test copy constructor" << endl;
    cout << " #   : Test assignment operator" << endl;
    cout << " M n : Move data item marked by cursor to pos. n ("
#if LAB3_TEST2
         << "Active   "
#else
         << "Inactive "
#endif   // LAB3_TEST2
         << ": In-lab Ex. 2)" << endl;
    cout << " ?x : Search rest of list for x                  ("
#if LAB3_TEST3
         << "Active   "
#else
         << "Inactive "
#endif   // LAB3_TEST3
         << ": In-lab Ex. 3)" << endl;
    cout << " Q   : Quit the test program" << endl;
    cout << endl;
}


ListArray.h

/--------------------------------------------------------------------

#ifndef LISTARRAY_H
#define LISTARRAY_H

#include <stdexcept>
#include <iostream>

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

/**
*Lab3: List                               ListArray.cpp
*Claire Ujeneza & Christian Uwimana & Jerry Groom
*2/22/2015
*/

#include "ListArray.h"
#include <iostream>
#include <iomanip>
using namespace std;

template <typename DataType>
List<DataType>::List(int maxNumber)
{
maxSize=maxNumber;
size=0;
cursor=-1;
dataItems=new DataType[maxSize];
}
//copy constructor
template <typename DataType>
List<DataType>::List(const List& source){
maxSize=source.maxSize;
size= source.size;
cursor=source.cursor;
dataItems = new DataType [maxSize];
    for ( int i = 0; i<size ; i++){
        dataItems[i]= source.dataItems[i];
    }
}

template <typename DataType>
List<DataType>& List<DataType>::operator=(const List& source)
{

if (this!= & source){

    delete [] dataItems;
    size=source.size;
    maxSize=source.maxSize;
    cursor=source.cursor;
   dataItems=new DataType [maxSize];

}
for(int i=0;i<size;i++){
    dataItems[i]=source.dataItems[i];
}

return *this;
}

template <typename DataType>
List<DataType>::~List()
{
    delete[] dataItems;
}
template <typename DataType>
void List<DataType>::insert(const DataType& newDataItem) throw (logic_error)
{
    if (size==maxSize)
          throw logic_error("List is full");
   else
   {

           for(int i = size-1; i>cursor; i--){
            DataType initialI= dataItems[i] ;
            dataItems[i]=dataItems[i+1];
            dataItems[i+1]=initialI;
           }
        dataItems[cursor+1] = newDataItem;

size++;
cursor++;
   }
}

template <typename DataType>
void List<DataType>::remove() throw (logic_error)
{
     if(size==0){
         throw logic_error("the list is empty");
     }else{
       if (cursor == size-1)
       {
           size--;
           gotoBeginning();
       }
       else
       {
           for (int i = cursor;i<size;i++)
           {
               dataItems[i]=dataItems[i+1];
           }
       size--;
       }
   }

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

if(size==0){
        throw logic_error("The List is full");
}
else{


        dataItems[cursor]=newDataItem; //Set the dataItems cursor Index value = to newDataItems value.
}
}


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

   size = 0;
   cursor=0;

}
template <typename DataType>
bool List<DataType>::isEmpty() const        // isEmpty
{

   if(size==0)
       return true;
   else
       return false;
}


template <typename DataType>            // is full method
bool List<DataType>::isFull() const
{
if(size!= MAX_LIST_SIZE)
       return false;
   else
       return true;
}

template <typename DataType>
void List<DataType>::gotoBeginning()   throw (logic_error)        //go to the beginning
{
    if(size==0){
        throw logic_error("The List is empty");
    }
    else{
        cursor = 0;
    }

}

template <typename DataType>
void List<DataType>::gotoEnd()     throw (logic_error)             //go to the end
{
    if(size==0){
        throw logic_error("The List is empty");
    }
    else{
        cursor = size - 1;
    }
}


template <typename DataType>
bool List<DataType>::gotoNext() throw (logic_error)
{

if(size==0){
    throw logic_error("The List is empty");
}
else{
    if(cursor<size-1){
        cursor++;
        return true;
    }
}
return false;
}


template <typename DataType>
bool List<DataType>::gotoPrior()   throw (logic_error)
{
    if(isEmpty()){
    throw logic_error("The List is empty");
}
else{
if(cursor!=0){
    cursor--;
    return true;
}
}
return false;
}


template <typename DataType>
DataType List<DataType>::getCursor() const         throw (logic_error)
{

if (isEmpty())
    throw logic_error("list is empty");
else
return dataItems[cursor];

}

template <typename DataType>
void List<DataType>:: 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;

    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;
    }
}

config.h


#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   1       // merge: programming exercise 2
#define LAB4_TEST2   0       // subset: programming exercise 3