(Solved Homework): C++ Programming Quick Assignment: Please make sure ALL parts are done and the code compiles and runs for a thumbs up :-)

C++ Programming Quick Assignment: Please make sure ALL parts are done and the code compiles and runs for a thumbs up 🙂

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;

#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

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;

}

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

}

}

test3dna.cpp:

//——————————————————————–

//

// 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 != ‘n’ )

{

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.

//