0

我正在尝试在我的 List 类中创建一个动态数组,该数组的大小从 2 开始,当您使用 Insert 方法插入值时,它将检查是否有足够的空间,如果没有,它将调整数组的大小a size + 2 ... 问题是它正在崩溃 VS 抱怨堆损坏。另外我认为我的复制构造函数没有被调用,因为 cout 没有显示:

list.h 文件:

class List
{
public:

    //  DEFAULT Constructor
    List();
    // Deconstructor to free memory allocated 
    ~List();// Prevent memory leaks

    // COPY Constructor for pointers
    List(const List& value);// copy constructor

    //Modification methods
    void Insert(const int);

    // User ACCESS methods
    void display(void) const;

private:
    int size;// MAX size of the array          
    int count;// current number of elements in the dynamic array

protected:
    int *intptr;// Our int pointer
};

list.cpp 实现文件:

#include "list.h" // Include our Class defintion
#include <iostream>

using namespace std;

// CONSTRUCTOR
List::List() {
    size = 2; // initial size of array
    count = 0;
    intptr = new int[size]; // Start off 2 integers sized array
}
// DECONSTRUCTOR
List::~List() {
    delete[] intptr; // free allocated memory
}

// Copy constructor

List::List(const List& value) {
    size = value.size;
    cout << "Copy con size : " << size << endl;
    count = value.count;

    cout << "Compy count : " << count << endl;
    if (count < size) {
        intptr = new int[size]; // Allocate new data
    } else {
        intptr = new int[size + 2]; // Allocate new data
    }

    for (int index = 0; index < count; index++) {
        intptr[index] = value.intptr[index];
    }

    size = size + 2;
    delete[] intptr;
    intptr = value.intptr;
}

void List::Insert(const int value) {
    // do we have room?
    if (count < size) {
        intptr[count] = value;
    } else { // if not we need to add more elements to array
        intptr[count] = value; // DEEP copy invoked with copy constructor
    }

    cout << "SIZE: " << size << endl;
    cout << "COUNT" << count << endl;
    count++; // Increase items added in array
}

void List::display() const {
    for (int i = 0; i < count; i++)
        cout << intptr[i] << endl;
}

main.cpp 测试器

#include <iostream>
#include "list.h"

int main()
{
    List mylist;

    mylist.Insert(5);
    mylist.Insert(6);
    mylist.Insert(2);
    mylist.Insert(8);
    mylist.Insert(4);
    mylist.Insert(5);
    mylist.Insert(9);
    mylist.Insert(8);
    mylist.Insert(5);
    mylist.Insert(9);
    mylist.Insert(8);
    mylist.Insert(5);
    mylist.Insert(9);
    mylist.Insert(8);
    mylist.Insert(5);
    mylist.Insert(9);

    mylist.display();

    system("PAUSE");
    return 0;
}
4

4 回答 4

8

您的List::Insert(const int value)方法根本不调用List复制构造函数,它只在intptr数组内部写入。当count大于时size,您在数组之外写入,这就是您有错误的原因。

您应该将您在复制构造函数中所做的Insert直接移动到方法中。

于 2012-10-19T21:39:15.733 回答
1

您没有正确管理阵列,尤其是在您的Insert()方法中。试试这个:

#include "list.h" // Include our Class defintion 
#include <iostream> 

// CONSTRUCTOR 
List::List()  
{ 
    intptr = new int[2];
    size = 2;
    count = 0; 

    std::cout << "Initial size : " << size << " count : " << count << std::endl; 
} 

// DECONSTRUCTOR 
List::~List() 
{ 
    delete [] intptr; // free allocated memory 
} 

// Copy constructor 
List::List(const List& value) 
{ 
    intptr = new int[value.size]; // Allocate new data 
    size = value.size; 
    count = value.count; 

    for(int index = 0; index < count; ++index) 
        intptr[index] = value.intptr[index]; 

    std::cout << "Copy size : " << size << " count : " << count << std::endl; 
} 

void List::Insert(const int value) 
{ 
    if (count == size)
    { 
        int *newintptr = new int[size+2];

        for(int index = 0; index < size; ++index) 
            newintptr[index] = intptr[index]; 

        delete[] intptr;
        intptr = newintptr;
        size += 2;
    }

    intptr[count] = value; 
    ++count;

    std::cout << "New size : " << size << " count : " << count << std::endl; 
} 

void List::display() const 
{ 
    for(int i = 0; i < count; i++) 
        std::cout << intptr[i] << std::endl; 
} 

.

#include <iostream> 
#include "list.h" 

int main() 
{ 
    List mylist; 

    mylist.Insert(5); 
    mylist.Insert(6); 
    mylist.Insert(2); 
    mylist.Insert(8); 
    mylist.Insert(4); 
    mylist.Insert(5); 
    mylist.Insert(9); 
    mylist.Insert(8); 
    mylist.Insert(5); 
    mylist.Insert(9); 
    mylist.Insert(8); 
    mylist.Insert(5); 
    mylist.Insert(9); 
    mylist.Insert(8); 
    mylist.Insert(5); 
    mylist.Insert(9); 

    mylist.display(); 
    system("PAUSE"); 

    List mylist2(myList); // copy construct a new list

    mylist2.display(); 
    system("PAUSE"); 

    return 0; 
} 

话虽如此,您确实应该std::vector改用,例如:

#include <iostream>            
#include <vector>
#include <algorithm>

void displayValue(int value)
{
    std::cout << value << std::endl; 
}

int main()            
{            
    std::vector<int> mylist;            

    mylist.push_back(5);            
    mylist.push_back(6);            
    mylist.push_back(2);            
    mylist.push_back(8);            
    mylist.push_back(4);            
    mylist.push_back(5);            
    mylist.push_back(9);            
    mylist.push_back(8);            
    mylist.push_back(5);            
    mylist.push_back(9);            
    mylist.push_back(8);            
    mylist.push_back(5);            
    mylist.push_back(9);            
    mylist.push_back(8);            
    mylist.push_back(5);            
    mylist.push_back(9);            

    std::for_each(mylist.begin(), myList.end(), displayValue);
    system("PAUSE");            

    std::vector<int> myList2(myList);

    std::for_each(mylist2.begin(), myList2.end(), displayValue);
    system("PAUSE");            

    return 0;            
 }       

更进一步,如果你想继续使用你的自定义List类,至少std::vector在它里面使用:

#include <vector>

class List  
{  
public:  
    //  DEFAULT Constructor  
    List();  

    //Modification methods  
    void Insert(const int);  

    // User ACCESS methods  
    void display(void) const;  

protected:  
    std::vector<int> intvec;
};

.

#include "list.h" // Include our Class defintion 
#include <iostream> 

// CONSTRUCTOR 
List::List()  
{ 
    intvec.reserve(2);
    std::cout << "Initial size : " << intvec.capacity() << " count : " << intvec.size() << std::endl; 
} 

// Copy constructor 
List::List(const List& value) 
{ 
    intvec = value.intvec;
    std::cout << "Copy size : " << invec.capacity() << " count : " << intvec.size() << std::endl; 
} 

void List::Insert(const int value) 
{ 
    intvec.push_back(value); 
    std::cout << "New size : " << intvec.capacity() << " count : " << intvec.size() << std::endl; 
} 

void List::display() const 
{ 
    for(std::vector<int>::const_iterator iter = intvec.begin(), end = intvec.end(); iter != end; ++iter) 
        std::cout << *iter << std::endl; 
} 

.

#include <iostream> 
#include "list.h" 

int main() 
{ 
    List mylist; 

    mylist.Insert(5); 
    mylist.Insert(6); 
    mylist.Insert(2); 
    mylist.Insert(8); 
    mylist.Insert(4); 
    mylist.Insert(5); 
    mylist.Insert(9); 
    mylist.Insert(8); 
    mylist.Insert(5); 
    mylist.Insert(9); 
    mylist.Insert(8); 
    mylist.Insert(5); 
    mylist.Insert(9); 
    mylist.Insert(8); 
    mylist.Insert(5); 
    mylist.Insert(9); 

    mylist.display(); 
    system("PAUSE"); 

    List mylist2(myList); // copy construct a new list

    mylist2.display(); 
    system("PAUSE"); 

    return 0; 
} 
于 2012-10-19T21:53:36.143 回答
1

复制构造函数的原因是从现有对象创建一个新对象,但是看看你的复制构造函数,你在那里做什么?

/* initialize my size and count, from value */
size = value.size;
count = value.count;

/* Check count and size */
if( count == size ) /* if other is full */
    size += 2;

/* copy content from value.intptr into this->intptr */
//if (count < size)
//    intptr = new int[size]; // Allocate new data
//else
//    intptr = new int[size + 2]; // Allocate new data
intptr = new int[size];  /* Allocate my buffer */

/* It's better to use std::copy in place of a hand written loop */
//for(int index = 0; index < count; index++)
//    intptr[index] = value.intptr[index];
std::copy( value.intptr, value.intptr + value.count, intptr );

/* why you increase your size here?? shouldn't this indicate size of intptr? */
//size = size + 2;

/* After creating a new buffer and putting data into it, you destroy the buffer
   and set your buffer equal to buffer of value? why? if value destroyed it will
   destroy its intptr and your intptr point to a deleted memory
*/
//delete [] intptr;
// intptr = value.intptr;

现在看看你的insert方法:

if(count < size) // do we have room?
{
    intptr[count] = value;
}
else // if not we need to add more elements to array
{
    /* As you already checked you do not have enough room to insert data to intptr
       so why you do it here? shouldn't you first allocate a new buffer and then
       copy data to it?
       In comment you say DEEP copy with copy-constructor, which copy constructor
       you expect to called here? you are assigning an int to another int, so where
       is copy constructor?
     */
    // intptr[count] = value; // DEEP copy invoked with copy constructor
    int* tmp = new int[size + 2];
    std::copy( intptr, intptr + size, tmp );
    delete[] intptr;
    intptr = tmp;
    size += 2;
    intptr[count] = value;
}

count++; // Increase items added in array
于 2012-10-19T21:58:40.597 回答
-1

使用 std::vector。它已经完成了所有这些,并且比您的代码更安全、更快。

于 2012-10-19T21:38:37.627 回答