0

假设我创建了一个自定义 Array 类并具有以下构造函数：

    Array::Array(size_t size)
    {
      mySize = size;
      //myData is of type int*
      myData = new int[mySize]; // this stuff is allocated on a heap
    }

据我所知，这种情况下的默认复制构造函数将像这样实现：

    Array::Array(Array& a)
    {
      mySize = a.mySize;
      myData = a.myData; //points to the same memory on the heap
    }

最后，假设我的 main.cpp 文件中有以下代码

     int main()
     {
       Array a(1);
       Array b(a); //copy constructor is invoked
     }

我期望的是由于删除指向空闲存储内存的 myData 指针而导致的内存泄漏，但我有以下运行时错误：

*** glibc detected *** ./main.out: double free or corruption (fasttop): 0x086ad008 ***

为什么？似乎 ~Array() 以某种方式自动释放分配在堆上的内存 - 但这对我来说非常违反直觉。也许我错过了什么？

更新：

      class Array{
         private:
           size_t mySize;
           int *myData;
           ...

更新 2：

主.cpp：

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

   int main()
   {
     Array a(1);
     Array b(a);
   }

数组.h：

   #ifndef ARRAY_H_
   #define ARRAY_H_
   #include <stddef.h>
   class Array{
   private:
       size_t mySize;
       int *myData;
   public:
       Array(size_t size);
       ~Array();
       void set(int i,int val);
       int get(int i);
       size_t getSize();
   };
   #endif

数组.cpp：

   #include "array.h"

   Array::Array(size_t size)
   {
     mySize = size;
     myData = new int[mySize];
   }

   Array::~Array()
   {
     delete[] myData;
   }

   void Array::set(int i, int val)
   {
     if(i>=0 && i<mySize)
       myData[i] = val;
   }

   int Array::get(int i)
   {
     if(i>=0 && i<mySize)
       return myData[i];
     else return -1;
   }
   size_t Array::getSize()
   {
     return mySize;
   }
4

5 回答 5

4

我认为在你的析构函数中你有

 Array::~Array(void)
 {
      delete [] myData; //points to the same memory on the heap
 }

问题是双重免费的

例子：

int main()
{
       Array a(1);  // here a.myData = 0x12345678
       Array b(a); //copy constructor is invoked // here b.myData = 0x12345678

       // pop  stack (call destroy of object)
       // delete b.myData
       // delete a.myData already delete
}

双人免费

编辑： 供您的复制构造器使用const，因为您不修改 a.

 Array::Array(const Array& a)
 {
      mySize = a.mySize;
      myData = a.myData; //points to the same memory on the heap
 }

祝你好运 ！

于 2013-03-06T21:59:38.933 回答
3

所以......尽管你声称，事实证明你确实删除了析构函数中的数组，而复制构造函数是一个浅拷贝，所以你得到了双重删除。简单的。

Array::~Array()
{
  delete[] myData;
}

由于这是一个动态数组，它应该拥有数据，因此您可以在析构函数中删除，但您需要在复制构造函数和赋值运算符中“深度”复制。见三法则。

于 2013-03-06T22:11:50.607 回答
2

你的副本是浅拷贝，所以如果你有一个释放内存的析构函数，每个对象都会尝试删除相同的内存。

你不必做一个浅拷贝。您可以编写自己的显式复制构造函数，将实际数据复制到新分配的数组中。

我喜欢谷歌关于禁用复制和赋值构造函数并更喜欢显式CopyFrom()方法的建议。

于 2013-03-06T22:02:40.110 回答
1

“double free”意味着同一个指针被赋予了delete[]两次。因为在你的析构函数中（大概）它delete[]在 objecta和b. 实用的解决方案：使用std::vector，不要乱用原始数组等。

于 2013-03-06T22:00:01.427 回答
0

我认为你的析构函数（来自数组'a'和'b'）正在尝试释放相同的内存（双重释放）。也许你应该在释放之前检查你的 myData 。

于 2013-03-06T22:03:05.597 回答