C++ - 动态数组转换为垃圾

Question

我正在尝试为动态调整大小的序列类创建一个实现文件。这是一项家庭作业，根据作业的限制，我只允许弄乱我编写的实现文件。

问题是当我创建动态数组时它看起来是垃圾，没有真正的值(value)并且根本不像数组。当我在调试器中查看它时，我经常得到一个类似 -6.2774385622041925e+066 的值(更新:这是由 Anders K. 的 catch 解决的，尽管现在我在调试器中查看时我得到 1 个 Vanilla 数字而不是像我应该的那样的整个数组，输出显示第一个元素之后的任何元素仍然是一个疯狂的怪异数字)。同样在某个时间点之后，程序停止运行并提示堆损坏，我怀疑它直接链接到显示为不稳定值的数组。

感谢任何帮助。不是在寻找淘汰的解决方案或任何东西，但我一定是在某个地方做错了什么惹恼了堆。就像我说的，我只写了实现文件，所以它当然可能是错误的。 >.>

更新:粘贴了新的和清理过的代码版本，这样其他愚蠢的错误就不会妨碍大错误。

这是我的实现文件(我唯一可以更改的)sequence.cpp:

#include "sequence.h"
using namespace main_savitch_4;

typedef double value_type;
typedef std::size_t size_type;

sequence::sequence(size_type initial_capacity){
    data = new value_type[initial_capacity];
    used = 0;
    current_index = initial_capacity + 1;
    capacity = initial_capacity;
}

sequence::sequence(const sequence& source){
    capacity = source.size();
    used = capacity;
    current_index = capacity + 1;
    data = new value_type[capacity];
    for (int i = 0; i < used; i++)
        data[i] = source.data[i];
}

sequence::~sequence(){
    delete [] data;
}

void sequence::resize(size_type new_capacity){
    if (new_capacity > used){
        value_type *temp = new value_type[new_capacity];
        for(int i = 0; i < used; i++)
            temp[i] = data[i];
        value_type *destroyme = data;
        data = temp;
        delete [ ] destroyme;
        capacity = new_capacity;
    }
}

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

void sequence::advance( ){
    current_index += 1;
}

void sequence::insert(const value_type& entry){
    if (used + 1 > capacity){
        resize(capacity + 5);
    }
    value_type *temp = new value_type[capacity];
    int i(0);
    if (is_item()){
        for(i=i;  i < current_index; i++)
            temp[i] = data[i];
        temp[i] = entry;
        current_index = i;
        i++;
        for(i=i;  i < used; i++)
                temp[i] = data[i];

        value_type *destroyme = data;
        data = temp;
        delete [ ] destroyme;

    }
    else{
        for(int i = used; i > 0; i--)
            data[i] = data[i - 1];
        data[0] = entry;
        current_index = 0;
    }


    used += 1;
}

void sequence::attach(const value_type& entry){
    if (used + 1 > capacity){
        resize(capacity + 5);
    }
    value_type *temp = new value_type[capacity];
    if (is_item()){
        int i(0);
        for(i;  i <= current_index + 1; i++)
            temp[i] = data[i];
        temp[i] = entry;
        current_index = i;
        for(i;  i <= used; i++)
            temp[i] = data[i];
        value_type *destroyme = data;
        data = temp;
        delete [ ] destroyme;       
    }
    else{
        data[used] = entry;
        current_index = used;
    }

    used+= 1;

}

void sequence::remove_current(){
    for(int i = current_index; i < used; i++)
        data[i] = data[i + 1];
    used = used - 1;
}

void sequence::operator=(const sequence& source){
    capacity = source.size();
    used = capacity;
    current_index = capacity + 1;
    data = new value_type[capacity];
    for (int i = 0; i < used; i++)
        data[i] = source.data[i];
}

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

bool sequence::is_item() const{
    if (current_index < used)
        return true;
    else
        return false;
}

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

这里是相关的头文件sequence.h:

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

namespace main_savitch_4
{
    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 attach(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

运行时得到以下输出:

Running tests for sequence class with a dynamic array

START OF TEST 1:
Testing insert, attach, and the constant member functions (4 points).
Starting with an empty sequence.
Testing that size() returns 0 ... Passed.
Testing that is_item() returns false ... Passed.
I'll call start() and look at the items one more time...
All tests passed for this sequence.

I am now using attach to put 10 into an empty sequence.
Testing that size() returns 1 ... Passed.
Testing that is_item() returns true ... Passed.
The cursor should be at item [0] of the sequence
(counting the first item as [0]). I will advance the cursor
to the end of the sequence, checking that each item is correct...Passed.
I'll call start() and look at the items one more time...
The cursor should be at item [0] of the sequence
(counting the first item as [0]). I will advance the cursor
to the end of the sequence, checking that each item is correct...Passed.
All tests passed for this sequence.

I am now using insert to put 10 into an empty sequence.
Testing that size() returns 1 ... Passed.
Testing that is_item() returns true ... Passed.
The cursor should be at item [0] of the sequence
(counting the first item as [0]). I will advance the cursor
to the end of the sequence, checking that each item is correct...Passed.
I'll call start() and look at the items one more time...
The cursor should be at item [0] of the sequence
(counting the first item as [0]). I will advance the cursor
to the end of the sequence, checking that each item is correct...Passed.
All tests passed for this sequence.

I am now using attach to put 10,20,30 in an empty sequence.
Then I move the cursor to the start and insert 5.
Testing that size() returns 4 ... Passed.
Testing that is_item() returns true ... Passed.
The cursor should be at item [0] of the sequence
(counting the first item as [0]). I will advance the cursor
to the end of the sequence, checking that each item is correct...
    The item [1] should be 10,
    but it was -6.27744e+066 instead.
Failed.
Test of the sequence's items failed.

Test 1 failed.
END OF TEST 1.


START OF TEST 2:
Testing situations where the cursor goes off the sequence (4 points).
Using attach to put 20 and 30 in the sequence, and then calling
advance, so that is_item should return false ... passed.
Inserting 10, which should go at the sequence's front.
Then calling advance three times to run cursor off the sequence ... passed.
Calling attach to put the numbers 40, 50, 60 ...300 at the sequence's end.
Now I will test that the sequence has 10, 20, 30, ...300.
    Test failed to find 30
Test 2 failed.
END OF TEST 2.


START OF TEST 3:
Testing remove_current (4 points).
Using attach to build a sequence with 10,30.
Insert a 20 before the 30, so entire sequence is 10,20,30.
Testing that size() returns 3 ... Passed.
Testing that is_item() returns true ... Passed.
The cursor should be at item [1] of the sequence
(counting the first item as [0]). I will advance the cursor
to the end of the sequence, checking that each item is correct...
    The item [2] should be 30,
    but it was 10 instead.
Failed.
Test of the sequence's items failed.

Test 3 failed.
END OF TEST 3.


START OF TEST 4:
Testing the resize member function (2 points).
I will now resize a sequence to a larger capacity, and then
attach that many items. The sequence should NOT need to
resize itself under this situation.
    sequence does not contain correct items.

Answer 1

这个片段看起来有点不可靠(插入):

  for(int i = used; i > 0; i--)
   data[used] = data[i - 1];

我认为你应该做的是在你的方法中添加断言以确保这些值符合您的预期。