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&#39;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 == &#39;+&#39; || cmd == &#39;=&#39; || cmd == &#39;?&#39; )

cin >> testData;

else if ( cmd == &#39;M&#39; || cmd == &#39;m&#39; )

cin >> n;

switch ( cmd )

{

case &#39;H&#39; : case &#39;h&#39;:

print_help();

break;

case &#39;+&#39; : // insert

cout

try

{

testList.insert(testData);

}

catch (logic_error &e)

{

cerr

}

break;

case &#39;-&#39; : // remove

cout

try

{

testList.remove();

}

catch (logic_error &e)

{

cerr

}

break;

case &#39;=&#39; : // replace

cout

try

{

testList.replace(testData);

}

catch (logic_error &e)

{

cerr

}

break;

case &#39;@&#39; : // getCursor

try

{

cout

}

catch (logic_error &e)

{

cerr

}

break;

case &#39;

cout

try

{

testList.gotoBeginning();

}

catch (logic_error &e)

{

cerr

}

break;

case &#39;>&#39; : // gotoEnd

cout

try

{

testList.gotoEnd();

}

catch (logic_error &e)

{

cerr

}

break;

case &#39;N&#39; : case &#39;n&#39; : // gotoNext

try

{

if ( testList.gotoNext() )

cout

else

cout

}

catch (logic_error &e)

{

cerr

}

break;

case &#39;P&#39; : case &#39;p&#39; : // gotoPrior

try

{

if ( testList.gotoPrior() )

cout

else

cout

}

catch (logic_error &e)

{

cerr

}

break;

case &#39;C&#39; : case &#39;c&#39; : // clear

cout

testList.clear();

break;

case &#39;E&#39; : case &#39;e&#39; : // isEmpty

if ( testList.isEmpty() )

cout

else

cout

break;

case &#39;F&#39; : case &#39;f&#39; : // isFull

if ( testList.isFull() )

cout

else

cout

break;

case &#39;!&#39; :

showTwoLists(copyList, testList);

break;

case &#39;#&#39; :

assignList.insert(&#39;x&#39;);

assignList = testList;

showTwoLists(assignList, testList);

break;

#if LAB3_TEST2

case &#39;M&#39; : case &#39;m&#39; : // In-lab Exercise 2

cout

try

{

testList.moveToNth(n);

}

catch (logic_error &e)

{

cerr

}

break;

#endif // LAB3_TEST1

#if LAB3_TEST3

case &#39;?&#39; : // In-lab Exercise 3

try

{

if ( testList.find(testData) )

cout

else

cout

}

catch (logic_error &e)

{

cerr

}

break;

#endif // LAB3_TEST3

case &#39;Q&#39; : case &#39;q&#39; : // Quit test program

break;

default : // Invalid command

cout

}

}

while ( cin && cmd != &#39;Q&#39; && cmd != &#39;q&#39; );

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

}

“Get 15% discount on your first 3 orders with us”
Use the following coupon
FIRST15

Order Now