C++ Programming Lab 3. Please only answer if you can do the ENTIRE problem. DO N
ID: 3869307 • Letter: C
Question
C++ Programming Lab 3. Please only answer if you can do the ENTIRE problem. DO NOT MAKE YOUR OWN CPP FILES, VARIABLES, ETC. UPLOAD ALL OF THE EXACT .CPP AND .H FILES AS I HAVE THEM JUST COMPLETED. Reattach all files I have below even if you didn't have to edit one. Program MUST compile and all these instructions followed in order for me to give a thumbs up, thank you :-)
Parts to complete:
- implement the ListArray ADT (60 points) [the declaration is given in ListArray.h]
- implement the following operations:
- constructor, assignment operator, destructor
- insert, remove, replace, clear
- isFull, isEmpty
- gotoBeginning, gotoEnd, gotoNext, gotoPrior, getCursor
- Programming Exercise 2: implement the member function moveToNth(...) that removes the item marked by the cursor and inserts it as the nth element of the list; test your implementation by turning the flag LAB3_TEST2 from 0 to 1 in config.h; (20 points)
- Programming Exercise 3: implement the ListArray member function find(...) that searches for the element given as a parameter; the search starts at the cursor and stops when it finds the element or at the end of the list; the cursor remains on the last position searched; test you implementation by turning the flag LAB3_TEST3 from 0 to 1 in config.h; (20 points)
test3dna.cs:
//--------------------------------------------------------------------
//
// Laboratory 3, In-lab Exercise 1 test3dna.cpp
//
// Test program for the countbases function
//
//--------------------------------------------------------------------
// Reads a DNA sequence from the keyboard, calls function countBases
// countBases (which uses a list to represent a DNA sequence), and
// outputs the number of times that each base (A, G, C and T) occurs
// in the sequence.
#include <iostream>
#include "ListArray.cpp"
using namespace std;
//--------------------------------------------------------------------
//
// Function prototype
//
void countBases ( List<char> &dnaSequence,
int &aCount,
int &cCount,
int &tCount,
int &gCount );
//--------------------------------------------------------------------
int main ()
{
List<char> dnaSequence(25); // DNA sequence (25 bases max.)
char base; // DNA base
int aCount, // Number of A's in the sequence
cCount, // Number of C's in the sequence
tCount, // Number of T's in the sequence
gCount; // Number of G's in the sequence
// Read the DNA sequence from the keyboard.
cout << endl << "Enter a DNA sequence: ";
cin.get(base);
while ( base != ' ' )
{
dnaSequence.insert(base);
cin.get(base);
}
// Display the sequence.
cout << "Sequence: ";
if( dnaSequence.isEmpty() )
cout << "list is empty" << endl;
else
{
dnaSequence.gotoBeginning();
do
{
cout << dnaSequence.getCursor() << " ";
} while ( dnaSequence.gotoNext() );
cout << endl;
}
// Count the number of times that each base occurs.
countBases(dnaSequence,aCount,cCount,tCount,gCount);
// Output the totals.
cout << "Number of A's : " << aCount << endl;
cout << "Number of C's : " << cCount << endl;
cout << "Number of T's : " << tCount << endl;
cout << "Number of G's : " << gCount << endl;
}
//--------------------------------------------------------------------
//
// Insert your countBases function below.
//
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.cpp:
#include "ListArray.h"
template < typename DataType >
List<DataType>::List ( int maxNumber )
{
}
template < typename DataType >
List<DataType>::List ( const List& source )
{
}
template < typename DataType >
List<DataType>& List<DataType>::operator= ( const List& source )
{
return *this;
}
template < typename DataType >
List<DataType>::~List ()
{
}
template < typename DataType >
void List<DataType>::insert ( const DataType& newDataItem )
throw ( logic_error )
{
}
template < typename DataType >
void List<DataType>::remove () throw ( logic_error )
{
}
template < typename DataType >
void List<DataType>::replace ( const DataType& newDataItem )
throw ( logic_error )
{
}
template < typename DataType >
void List<DataType>::clear ()
{
}
template < typename DataType >
bool List<DataType>::isEmpty () const
{
return false;
}
template < typename DataType >
bool List<DataType>::isFull () const
{
return false;
}
template < typename DataType >
void List<DataType>::gotoBeginning ()
throw ( logic_error )
{
}
template < typename DataType >
void List<DataType>::gotoEnd ()
throw ( logic_error )
{
}
template < typename DataType >
bool List<DataType>::gotoNext ()
throw ( logic_error )
{
return false;
}
template < typename DataType >
bool List<DataType>::gotoPrior ()
throw ( logic_error )
{
return false;
}
template < typename DataType >
DataType List<DataType>::getCursor () const
throw ( logic_error )
{
DataType t;
return t;
}
#include "show3.cpp"
template < typename DataType >
void List<DataType>::moveToNth ( int n )
throw ( logic_error )
{
}
template < typename DataType >
bool List<DataType>::find ( const DataType& searchDataItem )
throw ( logic_error )
{
return false;
}
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 <stdexcept>
#include <iostream>
using namespace std;
#pragma warning( disable : 4290 )
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
show3.cpp:
//--------------------------------------------------------------------
//
// Laboratory 3 show3.cpp
//
// Array implementation of the showStructure operation for the
// List ADT
//
//--------------------------------------------------------------------
#include "ListArray.h"
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;
// 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 << " ";
cout << endl;
for ( j = 0 ; j < size ; j++ ) {
if( j == cursor ) {
cout << "[";
cout << dataItems[j]
#ifdef ORDEREDLIST_CPP
.getKey()
#endif
;
cout << "]";
cout << " ";
}
else
cout << dataItems[j]
#ifdef ORDEREDLIST_CPP
.getKey()
#endif
<< " ";
}
cout << endl;
}
}
sumintegers.cpp:
#include <iostream>
#include "ListArray.cpp" // Note that we are including the file
// containing the code -- NOT the header file
using namespace std;
int main ()
{
List<int> samples(100); // Set of samples
int newSample, // Input sample
sum = 0; // Sum of the input samples
// Read in a set of samples from the keyboard.
cout << "Enter list of samples (end with EOF) : ";
while ( cin >> newSample ) {
samples.insert(newSample);
}
// Sum the samples and output the result.
if ( ! samples.isEmpty() ) // If have data
{
samples.gotoBeginning(); // First set cursor to beginning of list
do {
sum += samples.getCursor(); // Add data item to running sum
} while ( samples.gotoNext() ); // Go to next data item (if any)
}
cout << "Sum is " << sum << endl;
return 0;
}
test3.cpp:
//--------------------------------------------------------------------
//
// Laboratory 3 test3.cpp
//
// Test program for the operations in the List ADT
//
//--------------------------------------------------------------------
#include <iostream>
using namespace std;
// Because of C++ template implementations, must include source for templated class
// That is ugly, but it is required.
#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()
{
// hack: put a "try/catch" with list creation code?
// we need to demonstrate use of the try/catch syntax.
#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;
}
Explanation / Answer
#include <iostream>
#include "config.h"
#include "ListLinked.cpp"
using namespace std;
void print_help();
int main()
{
#if LAB5_TEST1
List<int> testList; // Test list
int testData; // List data item
#else
List<char> testList; // Test list
char testData; // List data item
#endif
char cmd; // Input command
print_help();
do
{
testList.showStructure(); // Output list
cout << endl << "Command: "; // Read command
cin >> cmd;
if (cmd == '+' || cmd == '=' || cmd == '#')
cin >> testData;
switch (cmd)
{
case 'H': case 'h':
print_help();
break;
case '+': // insert
cout << "Insert " << testData << endl;
testList.insert(testData);
break;
case '-': // remove
cout << "Remove the data item marked by the cursor"
<< endl;
testList.remove();
break;
case '=': // replace
cout << "Replace the data item marked by the cursor "
<< "with " << testData << endl;
testList.replace(testData);
break;
case '@': // getCursor
cout << "Element marked by the cursor is "
<< testList.getCursor() << endl;
break;
case '<': // gotoBeginning
testList.gotoBeginning();
cout << "Go to the beginning of the list" << endl;
break;
case '>': // gotoEnd
testList.gotoEnd();
cout << "Go to the end of the list" << endl;
break;
case 'N': case 'n': // gotoNext
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;
break;
case 'P': case 'p': // gotoPrior
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;
break;
case 'C': case 'c': // clear
cout << "Clear the list" << endl;
testList.clear();
break;
case 'E': case 'e': // empty
if (testList.isEmpty())
cout << "List is empty" << endl;
else
cout << "List is NOT empty" << endl;
break;
case 'F': case 'f': // full
if (testList.isFull())
cout << "List is full" << endl;
else
cout << "List is NOT full" << endl;
break;
#if LAB5_TEST2
case 'M': case 'm': // In-lab Exercise 2
cout << "Move the data item marked by the cursor to the "
<< "beginning of the list" << endl;
testList.moveToBeginning();
break;
#endif
#if LAB5_TEST3
case '#': // In-lab Exercise 3
cout << "Insert " << testData << " before the "
<< "cursor" << endl;
testList.insertBefore(testData);
break;
#endif
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)
{
// This is useful if students are testing the list with ints, instead of
// chars, and accidentally enter a non-digit char.
cout << "cin read errror" << endl;
}
return 0;
}
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 << " M : Move data item marked by cursor to beginning "
<< "(" <<
#if LAB5_TEST2
" Active "
#else
"Inactive "
#endif
<< ": In-lab Ex. 2)" << endl;
cout << " #x : Insert x before the cursor "
<< " (" <<
#if LAB5_TEST3
" Active "
#else
"Inactive "
#endif
<< " : In-lab Ex. 3)" << endl;
cout << " Q : Quit the test program" << endl;
cout << endl;
}
ListLinked.cpp
#include "ListLinked.h"
// ListNode member functions
template <typename DataType>
List<DataType>::ListNode::ListNode(const DataType& nodeData, ListNode* nextPtr)
{
this->dataItem = nodeData;
this->next = nextPtr;
}
// List member functions
template <typename DataType>
List<DataType>::List(int ignored = 0)
{
head = 0;
cursor = 0;
}
template <typename DataType>
List<DataType>::List(const List& other)
{
ListNode* copy = other.head;
while (copy != NULL) {
this->dataItem = copy->dataItem;
this->next = copy->next;
gotoNext();
copy = copy->next;
}
*this = other;
}
template <typename DataType>
List<DataType>& List<DataType>::operator=(const List& other)
{
ListNode* copy = other.head;
while (copy != NULL) {
insert(copy->dataItem);
gotoNext();
copy = copy->next;
}
return *this;
}
template <typename DataType>
List<DataType>::~List()
{
clear();
}
template <typename DataType>
void List<DataType>::insert(const DataType& newDataItem) throw (logic_error)
{
if (isEmpty())
{
head = new ListNode(newDataItem, 0);
cursor = head;
}
else
{
cursor->next = new ListNode(newDataItem, cursor->next);
cursor = cursor->next;
}
}
template <typename DataType>
void List<DataType>::remove() throw (logic_error)
{
ListNode* Node;
if (isEmpty()) {
cout << "Cannot remove from empty list." << endl;
}
else if (cursor == head) {
Node = head;
head = head->next;
gotoNext();
delete Node;
}
else {
ListNode* previous;
Node = cursor;
previous = head;
while (previous->next != cursor) {
previous = previous->next;
}
if (cursor->next != NULL)
cursor = cursor->next;
else
cursor = head;
previous->next = Node->next;
delete Node;
Node = NULL;
}
}
template <typename DataType>
void List<DataType>::replace(const DataType& newDataItem) throw (logic_error)
{
if (isEmpty()) throw logic_error("list is empty.");
if (head != NULL)
cursor->dataItem = newDataItem;
}
template <typename DataType>
void List<DataType>::clear()
{
if (isEmpty()) {
cout << "List is already empty!" << endl;
}
else {
cursor = head;
ListNode *Node;
while (cursor != NULL) {
Node = head;
head = head->next;
cursor = cursor->next;
delete Node;
}
head = NULL;
cursor = NULL;
}
}
template <typename DataType>
bool List<DataType>::isEmpty() const
{
return head == 0;
}
template <typename DataType>
bool List<DataType>::isFull() const
{
return false;
}
template <typename DataType>
void List<DataType>::gotoBeginning() throw (logic_error)
{
cursor = head;
}
template <typename DataType>
void List<DataType>::gotoEnd() throw (logic_error)
{
while (cursor->next != NULL)
{
cursor = cursor->next;
}
}
template <typename DataType>
bool List<DataType>::gotoNext() throw (logic_error)
{
if (cursor -> next!= NULL)
{
cursor = cursor->next;
return true;
}
else
return false;
}
template <typename DataType>
bool List<DataType>::gotoPrior() throw (logic_error)
{
if (cursor != head && head != NULL) {
ListNode *findPrior = head;
while (findPrior->next != cursor)
findPrior = findPrior->next;
cursor = findPrior;
return true;
}
else
return false;
}
template <typename DataType>
DataType List<DataType>::getCursor() const throw (logic_error)
{
if (!isEmpty()) {
return cursor->dataItem;
}
else {
throw logic_error("List is empty.");
}
}
template <typename DataType>
void List<DataType>::moveToBeginning() throw (logic_error)
{
if (cursor != head && head != NULL) {
ListNode* findPrior = head;
while (findPrior->next != cursor) {
findPrior = findPrior->next;
}
findPrior->next = cursor->next;
cursor->next = head;
head = cursor;
}
}
template <typename DataType>
void List<DataType>::insertBefore(const DataType& newDataItem) throw (logic_error)
{
if (isEmpty()) {
head = new ListNode(newDataItem, 0);
cursor = head;
}
else {
if (cursor == head) {
ListNode *node = new ListNode(newDataItem, head);
head = node;
cursor = node;
}
else {
gotoPrior();
insert(newDataItem);
}
}
}
#include "show5.cpp"
ListLinked.h
#ifndef LISTLINKED_H
#define LISTLINKED_H
#pragma warning( disable : 4290 )
#include <stdexcept>
#include <iostream>
using namespace std;
template <typename DataType>
class List {
public:
List(int ignored = 0);
List(const List& other);
List& operator=(const List& other);
~List();
void insert(const DataType& newDataItem) throw (logic_error);
void remove() throw (logic_error);
void replace(const DataType& newDataItem) throw (logic_error);
void clear();
bool isEmpty() const;
bool isFull() const;
void gotoBeginning() throw (logic_error);
void gotoEnd() throw (logic_error);
bool gotoNext() throw (logic_error);
bool gotoPrior() throw (logic_error);
DataType getCursor() const throw (logic_error);
// Programming exercise 2
void moveToBeginning() throw (logic_error);
// Programming exercise 3
void insertBefore(const DataType& newDataItem) throw (logic_error);
void showStructure() const;
private:
class ListNode {
public:
ListNode(const DataType& nodeData, ListNode* nextPtr);
DataType dataItem;
ListNode* next;
};
ListNode* head;
ListNode* cursor;
};
#endif
config.cpp
/**
* Linked List class (Lab 5) configuration file.
* Activate test #N by defining the corresponding LAB5_TESTN to have the value 1.
*/
#define LAB5_TEST1 0 // 1 means test with int instead of char
#define LAB5_TEST2 1 // Activate moveToBeginning (prog exercise 2)
#define LAB5_TEST3 1 // Activate insertBefore (prog exercise 3)
show5.cpp
//--------------------------------------------------------------------
// show5.cpp: includes implementation of showStructure
//--------------------------------------------------------------------
#include "ListLinked.h"
template <typename DataType>
void List<DataType>::showStructure() const
// Outputs the items in a list. If the list is empty, outputs
// "Empty list". This operation is intended for testing and
// debugging purposes only.
{
if ( isEmpty() )
{
cout << "Empty list" << endl;
}
else
{
for (ListNode* temp = head; temp != 0; temp = temp->next) {
if (temp == cursor) {
cout << "[";
}
// Assumes that dataItem can be printed via << because
// is is either primitive or operator<< is overloaded.
cout << temp->dataItem;
if (temp == cursor) {
cout << "]";
}
cout << " ";
}
cout << endl;
}
}
Related Questions
drjack9650@gmail.com
Navigate
Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.