Question

c++
Sequence class is a class that supports sequence of integers. Run the project ad verify that project works for integers. Next convert your sequence class into a template class. Demonstrate in your main function by using a sequence of int, float, string.

sequence.cxx
#include   // Provides assert
using namespace std;

namespace main_savitch_3
{
    sequence::sequence()
    {
        used = 0;
        current_index = 0;
    }

    void sequence::start()
    {
        current_index = 0;
    }

    void sequence::advance()
        // Library facilities used: assert.h
    {
        assert(is_item());
        current_index++;
    }

    void sequence::insert(const value_type& entry)
        // Library facilities used: assert.h
    {
        size_type i;

        // Check the precondition
        assert(size() < CAPACITY);

        // If there is no current item,
        // then set current_index to the front so that
        // the new entry will be placed at the front of the array.
        if (!is_item())
            current_index = 0;

        // Shift other items over, and insert the new entry at current_index
        for (i = used; i > current_index; i--)
            data[i] = data[i - 1];
        data[current_index] = entry;
        used++;
    }

    void sequence::attach(const value_type& entry)
        // Library facilities used: assert.h
    {
        size_type i;

        // Check the precondition
        assert(size() < CAPACITY);

        if (!is_item()) // There is no current item, so insert at end
            data[current_index] = entry;
        else // There is a current item, so move items over to make room
        {
            for (i = used; i > current_index + 1; i--)
                data[i] = data[i - 1];
            data[current_index + 1] = entry;
            current_index++;
        }

        used++;
    }

    void sequence::remove_current()
        // Library facilties used: assert.h
    {
        size_type i;

        assert(is_item());

        for (i = current_index + 1; i < used; i++)
            data[i - 1] = data[i];

        used--;
    }

    sequence::size_type sequence::size() const
    {
        return used;
    }

    bool sequence::is_item() const
    {
        return (current_index < used);
    }

    sequence::value_type sequence::current() const
        // Library facilities used: assert.h
    {
        assert(is_item());
        return data[current_index];
    }
}

sequence1.h

#ifndef MAIN_SAVITCH_SEQUENCE_H
#define MAIN_SAVITCH_SEQUENCE_H
#include <cstdlib>  // Provides size_t

namespace main_savitch_3
{
    class sequence
    {
    public:
        // TYPEDEFS and MEMBER CONSTANTS
        typedef double value_type;
        typedef std::size_t size_type;
        static const size_type 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:
        value_type data[CAPACITY];
        size_type used;
        size_type current_index;
    };
}

#endif

Answer 1

Note: Done accordingly. Please comment for any problem. Please Uprate. Thanks

Main.cpp

// FILE: sequence_test.cxx
// An interactive test program for the new sequence class
#include <cctype> // Provides toupper
#include <iostream> // Provides cout and cin
#include <cstdlib> // Provides EXIT_SUCCESS
#include "sequence.h" // With value_type defined as double
using namespace std;
using namespace main_savitch_3;

// PROTOTYPES for functions used by this test program:
void printMenu( );
// Postcondition: A menu of choices for this program has been written to cout.

char getUserCommand( );
// 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.

template <typename T>
void showSequence(sequence<T> display);
// Postcondition: The items on display have been printed to cout (one per line).

double getNumber( );
// 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<double> test; // A sequence that we’ll perform tests on
char choice; // A command character entered by the user

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

do
{
printMenu( );
choice = toupper(getUserCommand( ));
switch (choice)
{
case '1': test.start( );
break;
case '2': test.advance( );
break;
case '3': if (test.is_item( ))
cout << "There is an item." << endl;
else
cout << "There is no current item." << endl;
break;
case '4': if (test.is_item( ))
cout << "Current item is: " << test.current( ) << endl;
else
cout << "There is no current item." << endl;
break;
case '5': showSequence(test);
break;
case '6': cout << "Size is " << test.size( ) << '.' << endl;
break;
case '7': test.insert(getNumber( ));
break;
case '8': test.attach(getNumber( ));
break;
case '9': test.remove_current( );
cout << "The current item has been removed." << endl;
break;
case '10': cout << "Ridicule is the best test of truth." << endl;
break;
default: cout << choice << " is invalid." << endl;
}
}
while ((choice != 'Q'));

return EXIT_SUCCESS;
}

void printMenu( )
// Library facilities used: iostream.h
{
cout << endl; // Print blank line before the menu
cout << "The following choices are available: " << endl;
cout << " 1 Activate the start( ) function" << endl;
cout << " 2 Activate the advance( ) function" << endl;
cout << " 3 Print the result from the is_item( ) function" << endl;
cout << " 4 Print the result from the current( ) function" << endl;
cout << " 5 Print a copy of the entire sequence" << endl;
cout << " 6 Print the result from the size( ) function" << endl;
cout << " 7 Insert a new number with the insert(...) function" << endl;
cout << " 8 Attach a new number with the attach(...) function" << endl;
cout << " 9 Activate the remove_current( ) function" << endl;
cout << " Q Quit this test program" << endl;
}

char getUserCommand( )
// Library facilities used: iostream
{
char command;

cout << "Enter choice: ";
cin >> command; // Input of characters skips blanks and newline character

return command;
}

template <typename T>
void showSequence(sequence<T> display)
// Library facilities used: iostream
{
for (display.start( ); display.is_item( ); display.advance( ))
cout << display.current( ) << endl;
}

double getNumber( )
// 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;
}

sequence.h

#ifndef MAIN_SAVITCH_SEQUENCE_H
#define MAIN_SAVITCH_SEQUENCE_H
#include <cstdlib> // Provides size_t

namespace main_savitch_3
{
   template <class value_type>
class sequence
{
public:
// TYPEDEFS and MEMBER CONSTANTS
  
typedef std::size_t size_type;
static const size_type 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:
value_type data[CAPACITY];
size_type used;
size_type current_index;
};
}

#endif

Sequence.cpp

#include"sequence.h" // Provides assert
#include<assert.h>
using namespace std;

namespace main_savitch_3
{
   template <typename value_type>
sequence<value_type>::sequence()
{
used = 0;
current_index = 0;
}

   template <typename value_type>
void sequence<value_type>::start()
{
current_index = 0;
}

   template <typename value_type>
void sequence<value_type>::advance()
// Library facilities used: assert.h
{
assert(is_item());
current_index++;
}

   template <typename value_type>
void sequence<value_type>::insert(const value_type& entry)
// Library facilities used: assert.h
{
size_type i;

// Check the precondition
assert(size() < CAPACITY);

// If there is no current item,
// then set current_index to the front so that
// the new entry will be placed at the front of the array.
if (!is_item())
current_index = 0;

// Shift other items over, and insert the new entry at current_index
for (i = used; i > current_index; i--)
data[i] = data[i - 1];
data[current_index] = entry;
used++;
}

   template <typename value_type>
void sequence<value_type>::attach(const value_type& entry)
// Library facilities used: assert.h
{
size_type i;

// Check the precondition
assert(size() < CAPACITY);

if (!is_item()) // There is no current item, so insert at end
data[current_index] = entry;
else // There is a current item, so move items over to make room
{
for (i = used; i > current_index + 1; i--)
data[i] = data[i - 1];
data[current_index + 1] = entry;
current_index++;
}

used++;
}

   template <typename value_type>
void sequence<value_type>::remove_current()
// Library facilties used: assert.h
{
size_type i;

assert(is_item());

for (i = current_index + 1; i < used; i++)
data[i - 1] = data[i];

used--;
}

   template <typename value_type>
size_t sequence<value_type>::size() const
{
return used;
}

   template <typename value_type>
bool sequence<value_type>::is_item() const
{
return (current_index < used);
}

   template <typename value_type>
value_type sequence<value_type>::current() const
// Library facilities used: assert.h
{
assert(is_item());
return data[current_index];
}

   template class sequence<int>;
   template class sequence<float>;
   template class sequence<double>;
}

Output: