Asking for the 4th time, I hope i'll get a right code with showing successful compiled answers and steps.

The Assignment: data structure

You will implement and test the sequence class using an array to store the sequence's items.

Purposes:

Ensure that you can write a small class that uses an array as a private member variable.

Files that you must write and turn in:

1) sequence1.cpp:

// FILE: sequence1.h

// CLASS PROVIDED: sequence (part of the namespace main_savitch_3)

// There is no implementation file provided for this class since it is

// an exercise from Section 3.2 of "Data Structures and Other Objects Using C++"

//

// TYPEDEFS and MEMBER CONSTANTS for the sequence class:

// typedef ____ value_type

// sequence::value_type is the data type of the items in the sequence. It

// may be any of the C++ built-in types (int, char, etc.), or a class with a

// default constructor, an assignment operator, and a copy constructor.

//

// typedef ____ size_type

// sequence::size_type is the data type of any variable that keeps track of

// how many items are in a sequence.

//

// static const size_type CAPACITY = _____

// sequence::CAPACITY is the maximum number of items that a sequence can hold.

//

// CONSTRUCTOR for the sequence class:

// sequence( )

// Postcondition: The sequence has been initialized as an empty sequence.

//

// MODIFICATION MEMBER FUNCTIONS for the sequence class:

// void start( )

// Postcondition: The first item on the sequence becomes the current item

// (but if the sequence is empty, then there is no current item).

//

// void advance( )

// Precondition: is_item returns true.

// Postcondition: If the current item was already the last item in the

// sequence, then there is no longer any current item. Otherwise, the new

// current item is the item immediately after the original current item.

//

// void insert(const value_type& entry)

// Precondition: size( ) < CAPACITY.

// Postcondition: A new copy of entry has been inserted in the sequence

// before the current item. If there was no current item, then the new entry

// has been inserted at the front of the sequence. In either case, the newly

// inserted item is now the current item of the sequence.

//

// void attach(const value_type& entry)

// Precondition: size( ) < CAPACITY.

// Postcondition: A new copy of entry has been inserted in the sequence after

// the current item. If there was no current item, then the new entry has

// been attached to the end of the sequence. In either case, the newly

// inserted item is now the current item of the sequence.

//

// void remove_current( )

// Precondition: is_item returns true.

// Postcondition: The current item has been removed from the sequence, and the

// item after this (if there is one) is now the new current item.

//

// CONSTANT MEMBER FUNCTIONS for the sequence class:

// size_type size( ) const

// Postcondition: The return value is the number of items in the sequence.

//

// bool is_item( ) const

// Postcondition: A true return value indicates that there is a valid

// "current" item that may be retrieved by activating the current

// member function (listed below). A false return value indicates that

// there is no valid current item.

//

// value_type current( ) const

// Precondition: is_item( ) returns true.

// Postcondition: The item returned is the current item in the sequence.

//

// VALUE SEMANTICS for the sequence class:

// Assignments and the copy constructor may be used with sequence objects.

2) sequence1.h file:

#ifndef MAIN_SAVITCH_SEQUENCE_H

#define MAIN_SAVITCH_SEQUENCE_H

#include // Provides size_t

namespace main_savitch_3

{

class sequence

{

public:

// TYPEDEFS and MEMBER CONSTANTS

typedef double value_type;

typedef size_t size_type; //typedef std::size_t size_type;

static const size_type CAPACITY = 30; // enum {CAPACITY = 30}; //

// CONSTRUCTOR

sequence( );

// MODIFICATION MEMBER FUNCTIONS

void start( );

void advance( );

void insert(const value_type& entry);

void attach(const value_type& entry);

void remove_current( );

// CONSTANT MEMBER FUNCTIONS

size_type size( ) const;

bool is_item( ) const;

value_type current( ) const;

private:

-- Fill in your private member variables here.

-- Read Section 3.2 for guidelines.

};

}

#endif

sequence1.cpp: The implementation file for this first sequence class. You will write all of this file, which will have the implementations of all the sequence's member functions.

Test file:

3) sequence_test.cpp : A simple interactive test program

// FILE: sequence_test.cxx

// An interactive test program for the new sequence class

#include // Provides toupper

#include // Provides cout and cin

#include // Provides EXIT_SUCCESS

#include "sequence1.h" // With value_type defined as double

using namespace std;

using namespace main_savitch_3;

// PROTOTYPES for functions used by this test program:

void print_menu( );

// Postcondition: A menu of choices for this program has been written to cout.

char get_user_command( );

// Postcondition: The user has been prompted to enter a one character command.

// The next character has been read (skipping blanks and newline characters),

// and this character has been returned.

void show_sequence(sequence display);

// Postcondition: The items on display have been printed to cout (one per line).

double get_number( );

// Postcondition: The user has been prompted to enter a real number. The

// number has been read, echoed to the screen, and returned by the function.

int main( )

{

sequence test; // A sequence that well perform tests on

char choice; // A command character entered by the user

cout << "I have initialized an empty sequence of real numbers." << endl;

do

{

print_menu( );

choice = toupper(get_user_command( ));

switch (choice)

{

case '!': test.start( );

break;

case '+': test.advance( );

break;

case '?': if (test.is_item( ))

cout << "There is an item." << endl;

else

cout << "There is no current item." << endl;

break;

case 'C': if (test.is_item( ))

cout << "Current item is: " << test.current( ) << endl;

else

cout << "There is no current item." << endl;

break;

case 'P': show_sequence(test);

break;

case 'S': cout << "Size is " << test.size( ) << '.' << endl;

break;

case 'I': test.insert(get_number( ));

break;

case 'A': test.attach(get_number( ));

break;

case 'R': test.remove_current( );

cout << "The current item has been removed." << endl;

break;

case 'Q': cout << "Ridicule is the best test of truth." << endl;

break;

default: cout << choice << " is invalid." << endl;

}

}

while ((choice != 'Q'));

return EXIT_SUCCESS;

}

void print_menu( )

// Library facilities used: iostream.h

{

cout << endl; // Print blank line before the menu

cout << "The following choices are available: " << endl;

cout << " ! Activate the start( ) function" << endl;

cout << " + Activate the advance( ) function" << endl;

cout << " ? Print the result from the is_item( ) function" << endl;

cout << " C Print the result from the current( ) function" << endl;

cout << " P Print a copy of the entire sequence" << endl;

cout << " S Print the result from the size( ) function" << endl;

cout << " I Insert a new number with the insert(...) function" << endl;

cout << " A Attach a new number with the attach(...) function" << endl;

cout << " R Activate the remove_current( ) function" << endl;

cout << " Q Quit this test program" << endl;

}

char get_user_command( )

// Library facilities used: iostream

{

char command;

cout << "Enter choice: ";

cin >> command; // Input of characters skips blanks and newline character

return command;

}

void show_sequence(sequence display)

// Library facilities used: iostream

{

for (display.start( ); display.is_item( ); display.advance( ))

cout << display.current( ) << endl;

}

double get_number( )

// Library facilities used: iostream

{

double result;

cout << "Please enter a real number for the sequence: ";

cin >> result;

cout << result << " has been read." << endl;

return result;

}