sequence class

[susu5]

When I compile and run the program, no error is given.It gives me an unexpected result, and the output is
-858993460
. I thought it should give me the first
value of the array (check my main.cpp file). Please guide me to the right direction. Thanks!

 
// main.cpp 
#include <iostream>
#include "sequenceClass.h"
using namespace std;

int main()
{
	sequence bag;

	bag.insert(1);
	bag.insert(2);
	bag.insert(3);
	bag.insert(4);
	bag.insert(5);
	bag.start();
	cout << bag << endl;

	return 0;
} 

// sequenceclass.cpp 

#include <iostream>
#include <cassert>
#include <cstdlib>
#include "sequenceClass.h"
using namespace std;

//const sequence::size_type sequence::CAPACITY;

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

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

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

sequence::value_type sequence::current() const
{
	return data[current_index];

}

void sequence::advance()
{
	assert(is_item());
	current_index++;
}

//CONSTANT MEMBER FUNCTIONS
bool sequence::is_item() const
{
	return current_index < used;
}

// insert entry before the current item
void sequence::insert(const value_type& entry)
{
	assert(size() < CAPACITY);
	for (int i = used; i > current_index; i--)
	{
		data[i] = data[i - 1];
		data[current_index] = entry;
		used++;
	}
}

// insert entry after the current item
void sequence::attach(const value_type& entry)
{
	assert(size() < CAPACITY);
	for (int i = used; i > current_index; i--)
	{
		data[i] = data[i + 1];
		data[current_index] = entry;
		used++;
	}
}
void sequence::remove_current()
{
	assert(is_item());
	for (int i = current_index + 1; i < used - 1; i++)
	{
		data[i] = data[i + 1];
		used--;
	}
}

ostream& operator<< (ostream& outs, const sequence& source)
{
	outs << source.current() << " ";
	return outs;
}

// sequenceclass.h 

#ifndef SEQUENCECE_CLASS_H
#define SEQUENCECE_CLASS_H

#include <cstdlib>       // Provides size_t 
using namespace std;

class sequence
{
public:
	// TYPEDEFS and MEMBER CONSTANT
	typedef int value_type;
	typedef std::size_t size_type;
	static const size_type CAPACITY = 30;

	//CONSTRUCTOR
	sequence();

	//MODIFICATION MEMBER FUNCTIONS
	void start();
	void advance();
	// insert entry before the current item
	void insert(const value_type& entry);
	// insert entry after the current item
	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;
};
//NONMEMBER FUNCTIONS for the point class
ostream& operator<< (ostream& outs, const sequence& source);

#endif 

[Pindrought]

The problem is in your insert method.

// insert entry before the current item
void sequence::insert(const value_type& entry)
{
	assert(size() < CAPACITY);
	for (int i = used; i > current_index; i--)
	{
		data[i] = data[i - 1];
		data[current_index] = entry;
		used++;
	}
}

The for loop never goes off to actually insert the entry, because when it reaches the for loop, used == 0 and current_index == 0.

The for loop will only go off if i > current_index, but 0 will never be greater than 0. I'm not sure what you're trying to do with your insert method, but you should review the logic in that method, because that's where your issue is.