0
我想創建一個動態大小的序列類的實現文件。這是一項家庭作業，並且根據作業的侷限性，我被允許混淆我編寫的實現文件。C++ - 動態數組鑄造垃圾
問題是，當我創建動態數組時，它看起來像是垃圾，沒有真正的價值，而且根本不像數組。當我在調試器中看到它時，我經常會得到一個類似於-6.2774385622041925e + 066的值（更新：這是由Anders K.'s 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.
使用[copy-and-swap idiom]（http://stackoverflow.com/questions/3279543/what-is-the-copy-and-swap-idiom）。 – GManNickG 2011-01-20 05:14:42