// FILE: sequence2.h // CLASS PROVIDED: sequence (part of the namespace main_sav

Question

// FILE: sequence2.h

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

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

// an exercise from Chapter 4 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 DEFAULT_CAPACITY = _____

// sequence::DEFAULT_CAPACITY is the initial capacity of a sequence that is

// created by the default constructor.

//

// CONSTRUCTOR for the sequence class:

// sequence(size_t initial_capacity = DEFAULT_CAPACITY)

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

// The insert/append functions will work efficiently (without allocating

// new memory) until this capacity is reached.

//

// MODIFICATION MEMBER FUNCTIONS for the sequence class:

// void resize(size_type new_capacity)

// Postcondition: The sequence's current capacity is changed to the

// new_capacity (but not less that the number of items already on the

// list). The insert/append functions will work efficiently (without

// allocating new memory) until this new capacity is reached.

//

// 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)

// 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 append(const value_type& entry)

// 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 appended 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.

//

// DYNAMIC MEMORY USAGE by the List

// If there is insufficient dynamic memory, then the following functions

// throw a BAD_ALLOC exception: The constructors, insert, append.

#ifndef MYSEQUENCE_H

#define MYSEQUENCE_H

#include <cstdlib> // Provides size_t

namespace DSProject01

{

class sequence

{

public:

   // TYPEDEFS and MEMBER CONSTANTS

   typedef double value_type;

   typedef std::size_t size_type;

   static const size_type DEFAULT_CAPACITY = 30;

   // CONSTRUCTORS and DESTRUCTOR

   sequence(size_type initial_capacity = DEFAULT_CAPACITY);

   sequence(const sequence& source);

   ~sequence( );

   // MODIFICATION MEMBER FUNCTIONS

   void resize(size_type new_capacity);

   void start( );

   void advance( );

   void insert(const value_type& entry);

   void append(const value_type& entry);

   void remove_current( );

   void operator =(const sequence& source);

   // CONSTANT MEMBER FUNCTIONS

   size_type size( ) const;

   bool is_item( ) const;

   value_type current( ) const;

private:

   value_type* data;

   size_type used;

   size_type current_index;

   size_type capacity;

};

}

#endif

I need help implementing this. Thanks in Advance for any help that you can provide.

Explanation / Answer

Hi,

Try implementing this problem with the Lists as it has better performance than the other sequence container as it has already the iterator which ease down the work.

Start:

In start, assign the pointer iterator of the list to the First element under the check as:

//if(!List.empty)

Also, you can assign the end iterator to the last element as:

List.end=abc;

In Resize function, you can make use of the property of size of list as it will get you the updated item count.

For advance function , you can take one global bool parameter and set it to true in insert and delete functions and accordingly in advance function, you can set the start of the list to some element and set that bool parameter to false.

For insert and delete functions , you can use inbuilt modifiers of list as insert and erase ,using these you can insert and delete the elements.

In append function , you can use the swap function of the list container and swap the old item of list with the updated one.

In remove current function , you can use the erase modifier of the list container.

I hope this will solve your problem.please let me know if you find any problems.

Related Questions

Navigate

• Browse (All)
• Browse #
• Subjects

Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.