In this particular lab, you will need to implement the following functions for L

ID: 3746162 • Letter: I

Question

In this particular lab, you will need to implement the following functions for List ADT (array implementation) with C++ language(Not C or C# or Java):

PS: See important instruction at the end of this question.(If you don't understand what you need to do or any file might be missing)

a. Constructors and destructor

b. Assignment operator

c. List manipulation operations (insert, remove, replace, clear)

d. showStructure

After you implement the aforementioned functions, usetest3.cpp and OnlineTestPlan_Lab03.doc to test your code. And submit your ListArray.cpp.

Here's the files from List ADT:

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

show3.cpp:

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

// Laboratory 3 show3.cpp

// Array implementation of the showStructure operation for the

// List ADT

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

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

{

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;

}

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.
//

This question has included all the information you need to know. So basically, you need to do task a, b, c, d for programming only and don't worry about online test plan, if you don't want to do it, it's fine. You just need to know that in comments lots of things have talked about different exercises which are for the online test plan. Overall, just follow the instructions and I swear the question is complete.

Explanation / Answer

ListArray.cpp : ------------->>>>>>>>>>>>>>

#ifndef LIST_ARRAY_CPP
#define LIST_ARRAY_CPP

#include "ListArray.h"

template<typename DataType>
List<DataType>::List(int maxNumber){
dataItems = new DataType[maxNumber];
maxSize = maxNumber;
size = 0;
cursor = 0;
}
template<typename DataType>
List<DataType>::List(const List<DataType> &source):List(){
*this = source;
}
template<typename DataType>
List<DataType>& List<DataType>::operator=( const List<DataType>& source ){
if(&source == this){
return *this;
}
maxSize = source.maxSize;
size = source.size;
cursor = source.cursor;
delete[] dataItems;
dataItems = new DataType[maxSize];
for(int i = 0;i<size;i++){
dataItems[i] = source.dataItems[i];
}
return *this;
}

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

template<typename DataType>
void List<DataType>::clear(){
if(maxSize != -1){
  maxSize = -1;
  delete[] dataItems;
  size = 0;
  cursor = 0;
}
}

template<typename DataType>
void List<DataType>::insert(const DataType &newDataItem)throw (logic_error){
if(isFull()){
  throw logic_error("List Is Full");
}
if(size == cursor){
  dataItems[size++] = newDataItem;
  cursor++;
  return;
}
if(size != cursor){
  size++;
  for(int i = size;i>cursor;i--){
   dataItems[i] = dataItems[i-1];
  }
  dataItems[cursor++] = newDataItem;
}
}

template<typename DataType>
void List<DataType>::remove()throw (logic_error){
if(isEmpty()){
throw logic_error("List Is Empty");
}
for(int i = cursor-1;i<size-1;i++){
dataItems[i] = dataItems[i+1];
}
size--;
}

template<typename DataType>
void List<DataType>::replace(const DataType &newDataItem)throw (logic_error){
if(isEmpty()){
  throw logic_error("List Is Empty");
}
dataItems[cursor-1] = newDataItem;
}
template<typename DataType>
bool List<DataType>::isEmpty()const{
return size == 0;
}
template<typename DataType>
bool List<DataType>::isFull()const{
return size >= maxSize;
}
template<typename DataType>
void List<DataType>::gotoBeginning()throw ( logic_error ){
if(isEmpty()){
  throw logic_error("List Is Empty");
}
cursor = 1;
}
template<typename DataType>
void List<DataType>::gotoEnd()throw ( logic_error ){
if(isEmpty()){
  throw logic_error("List Is Empty");
}
cursor = size;
}
template<typename DataType>
bool List<DataType>::gotoNext()throw ( logic_error ){
if(isEmpty()){
  throw logic_error("List Is Empty");
}
if(cursor >= size){
  return false;
}
cursor++;
return true;
}
template<typename DataType>
bool List<DataType>::gotoPrior()throw ( logic_error ){
if(isEmpty()){
  throw logic_error("List Is Empty");
}
if(cursor <= 1){
  return false;
}
cursor--;
return true;
}
template<typename DataType>
DataType List<DataType>::getCursor () const throw ( logic_error ){
if(isEmpty()){
  throw logic_error("List Is Empty");
}
return dataItems[cursor-1];
}

template<typename DataType>
void List<DataType>::moveToNth ( int n )throw ( logic_error ){
if(isEmpty()){
throw logic_error("List Is Empty");
}
if(n < 0 || n >= size){
throw logic_error("Index Out Of Bound");
}
cursor = n+1;
}

template<typename DataType>
bool List<DataType>::find ( const DataType& searchDataItem )throw ( logic_error ){
if(isEmpty()){
  throw logic_error("List Is Empty");
}
for(int i = 0;i<size;i++){
  if(searchDataItem == dataItems[i]){
   return true;
  }
}

return false;
}

#endif

Navigate

In this particular experiment performed, 3 different metal-organic frameworks we

In this particular scenario, you are taking the perspective of a contractor who

Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.

In this particular lab, you will need to implement the following functions for L

Question

Explanation / Answer

Related Questions

Navigate