c programming please only answer if you can do the entire problem do not make your o 5150148
C++ Programming. 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
#include “ListArray.cpp”
using namespace std;
//——————————————————————–
//
// Function prototype
//
void countBases ( List &dnaSequence,
int &aCount,
int &cCount,
int &tCount,
int &gCount );
//——————————————————————–
int main ()
{
List 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
cin.get(base);
while ( base != 'n' )
{
dnaSequence.insert(base);
cin.get(base);
}
// Display the sequence.
cout
if( dnaSequence.isEmpty() )
cout
else
{
dnaSequence.gotoBeginning();
do
{
cout
} while ( dnaSequence.gotoNext() );
cout
}
// Count the number of times that each base occurs.
countBases(dnaSequence,aCount,cCount,tCount,gCount);
// Output the totals.
cout
cout
cout
cout
}
//——————————————————————–
//
// 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::List ( int maxNumber )
{
}
template < typename DataType >
List::List ( const List& source )
{
}
template < typename DataType >
List& List::operator= ( const List& source )
{
return *this;
}
template < typename DataType >
List::~List ()
{
}
template < typename DataType >
void List::insert ( const DataType& newDataItem )
throw ( logic_error )
{
}
template < typename DataType >
void List::remove () throw ( logic_error )
{
}
template < typename DataType >
void List::replace ( const DataType& newDataItem )
throw ( logic_error )
{
}
template < typename DataType >
void List::clear ()
{
}
template < typename DataType >
bool List::isEmpty () const
{
return false;
}
template < typename DataType >
bool List::isFull () const
{
return false;
}
template < typename DataType >
void List::gotoBeginning ()
throw ( logic_error )
{
}
template < typename DataType >
void List::gotoEnd ()
throw ( logic_error )
{
}
template < typename DataType >
bool List::gotoNext ()
throw ( logic_error )
{
return false;
}
template < typename DataType >
bool List::gotoPrior ()
throw ( logic_error )
{
return false;
}
template < typename DataType >
DataType List::getCursor () const
throw ( logic_error )
{
DataType t;
return t;
}
#include “show3.cpp”
template < typename DataType >
void List::moveToNth ( int n )
throw ( logic_error )
{
}
template < typename DataType >
bool List::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
#include
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
void List:: 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
// 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
// the ordered list.
else
{
cout
for ( j = 0 ; j
cout
cout
for ( j = 0 ; j
if( j == cursor ) {
cout
cout
#ifdef ORDEREDLIST_CPP
.getKey()
#endif
;
cout
cout
}
else
cout
#ifdef ORDEREDLIST_CPP
.getKey()
#endif
}
cout
}
}
sumintegers.cpp:
#include
#include “ListArray.cpp” // Note that we are including the file
// containing the code — NOT the header file
using namespace std;
int main ()
{
List 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
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
return 0;
}
test3.cpp:
//——————————————————————–
//
// Laboratory 3 test3.cpp
//
// Test program for the operations in the List ADT
//
//——————————————————————–
#include
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 list1, List 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 testList(8); // Test list to test with ints
List copyList(testList); // Used to test copy constructor
List assignList; // Used to test assignment operator
int testData; // List data item
#else
List testList(8); // Test list to test with chars
List copyList(testList); // Used to test copy constructor
List 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
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
try
{
testList.insert(testData);
}
catch (logic_error &e)
{
cerr
}
break;
case '-' : // remove
cout
try
{
testList.remove();
}
catch (logic_error &e)
{
cerr
}
break;
case '=' : // replace
cout
try
{
testList.replace(testData);
}
catch (logic_error &e)
{
cerr
}
break;
case '@' : // getCursor
try
{
cout
}
catch (logic_error &e)
{
cerr
}
break;
case '
cout
try
{
testList.gotoBeginning();
}
catch (logic_error &e)
{
cerr
}
break;
case '>' : // gotoEnd
cout
try
{
testList.gotoEnd();
}
catch (logic_error &e)
{
cerr
}
break;
case 'N' : case 'n' : // gotoNext
try
{
if ( testList.gotoNext() )
cout
else
cout
}
catch (logic_error &e)
{
cerr
}
break;
case 'P' : case 'p' : // gotoPrior
try
{
if ( testList.gotoPrior() )
cout
else
cout
}
catch (logic_error &e)
{
cerr
}
break;
case 'C' : case 'c' : // clear
cout
testList.clear();
break;
case 'E' : case 'e' : // isEmpty
if ( testList.isEmpty() )
cout
else
cout
break;
case 'F' : case 'f' : // isFull
if ( testList.isFull() )
cout
else
cout
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
try
{
testList.moveToNth(n);
}
catch (logic_error &e)
{
cerr
}
break;
#endif // LAB3_TEST1
#if LAB3_TEST3
case '?' : // In-lab Exercise 3
try
{
if ( testList.find(testData) )
cout
else
cout
}
catch (logic_error &e)
{
cerr
}
break;
#endif // LAB3_TEST3
case 'Q' : case 'q' : // Quit test program
break;
default : // Invalid command
cout
}
}
while ( cin && cmd != 'Q' && cmd != 'q' );
if( !cin ) {
cout
}
return 0;
}
void showTwoLists(List list1, List list2) {
// Variables should match, but dynamic memory buffer must be different
cout
cout
list1.showStructure();
cout
list2.showStructure();
cout
}
void print_help()
{
cout
cout
cout
cout
cout
cout
cout
cout << ” > : Go to the end of the list”
cout
cout
cout
cout
cout
cout
cout
cout
#if LAB3_TEST2
#else
#endif // LAB3_TEST2
cout
#if LAB3_TEST3
#else
#endif // LAB3_TEST3
cout
cout
}