C++ Programming Quick Assignment: Please make sure ALL parts are done and the co
ID: 3845475 • Letter: C
Question
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 << " ";
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;
}
}
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 != ' ' )
{
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.
//
Explanation / Answer
Hello there.
Here, you need to add this to ListArray.h:
// Gets the size.
int getSize() const;
Then add this implementation to ListArray.cpp:
// Gets size.
template <typename DataType>
int List<DataType>::getSize() const
{
cout << this->size << endl;
return this->size;
}
add this to your main function:
// count bases function.
void countBases (
List<char> &dnaSequence, int &aCount, int &cCount,
int &tCount, int &gCount )
{
dnaSequence.gotoBeginning();
cout << "Size of the sequence is: " << dnaSequence.getSize() << endl;
for (int i = 0; i < dnaSequence.getSize(); ++i)
{
dnaSequence.gotoNext();
switch (dnaSequence.getCursor())
{
case 65:
case 97:
++aCount;
break;
case 67:
case 99:
++cCount;
break;
case 84:
case 116:
++tCount;
break;
case 71:
case 103:
++gCount;
break;
}
}
}
This will not probably work because your methods do not update the size member of the class. I'll make that work too in an edit.
Cheers,
PH
Related Questions
drjack9650@gmail.com
Navigate
Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.