析构函数内存释放问题

tianhailong

今天遇到一个比较奇怪的问题，没搞明白，请教一下：
下边的程序 在构造函数中申请了堆内存，析构时释放，
执行了2次构造函数，3次析构函数，就会出现对一块内存两次释放，
可是程序还能正常执行，也不会coredump，不知道为什么呢？

#include <iostream>
using namespace std;

class Complex
{
public:
  float realPart;
  float virtualPart;
  char *p;
    Complex (float r, float v)
  {
    realPart = r;
    virtualPart = v;
    p = (char *) malloc (10);
    printf ("Construct %p\n", p);
  }
   ~Complex ()
  {
    free (p);
    printf ("Destruct %p\n", p);
  }
};


Complex
operator - (Complex c)
{
  return Complex (-c.realPart, -c.virtualPart);
}

int
main ()
{
  Complex c1 (11.1f, 22.2f);
  c1 = -c1;
  return 0;
}

执行结果如下：

Construct 0x502010
Construct 0x502030
Destruct 0x502030
Destruct 0x502010
Destruct 0x502030

可以看到，对 0x502030 做了两次释放，我觉得应该会coredump
但是却没有

fender0107401

执行了不止2次的构造函数吧。

你看到2次，是因为编译器给你构造的那个copy constructor里面没有print语句。

何必抱怨

事实上是malloc了一次，然后却free了两次。

在vs2008下我试了下，debug模式下是会报错的。
在g++ 4.6.3下试了一下，不会报错。

事实上lz的问题等价于：

1.         char *p1 = (char *) malloc (10);
   
2.         char *p2 = (char *) malloc (10);
   
3.         free(p1);
   
4.         free(p2);
   
5.         free(p1);

复制代码

为什么不会报错。

我尝试了一下，如果把上面的代码改为：

1.         char *p1 = (char *) malloc (10);
   
2.         char *p2 = (char *) malloc (10);
   
3.         free(p1);
   
4.         free(p1);

复制代码

在vs和g++下都会报错的。
中间插入了free(p2);之后，vs下会报错，g++下不会报错，这个暂时不知道什么原因。

lxyscls

回复 1# tianhailong


    "undefined behavior" 又不代表一定会coredump

lxyscls

回复 3# 何必抱怨

1. void
   
2. public_fREe(void* mem)
   
3. {
   
4.   mstate ar_ptr;
   
5.   mchunkptr p;                          /* chunk corresponding to mem */
   
6. 
   
7.   void (*hook) (__malloc_ptr_t, __const __malloc_ptr_t)
   
8.     = force_reg (__free_hook);
   
9.   if (__builtin_expect (hook != NULL, 0)) {
   
10.     (*hook)(mem, RETURN_ADDRESS (0));
    
11.     return;
    
12.   }
    
13. 
    
14.   if (mem == 0)                              /* free(0) has no effect */
    
15.     return;
    
16. 
    
17.   p = mem2chunk(mem);
    
18. 
    
19.   ... ...
    
20. 
    
21.   ar_ptr = arena_for_chunk(p);
    
22.   _int_free(ar_ptr, p, 0);
    
23. }

复制代码

对于较小的内存分配，都在chunk里面分配，使用_init_free()。

1. static void
   
2. _int_free(mstate av, mchunkptr p, int have_lock)
   
3. {
   
4.   INTERNAL_SIZE_T size;        /* its size */
   
5.   mfastbinptr*    fb;          /* associated fastbin */
   
6.   mchunkptr       nextchunk;   /* next contiguous chunk */
   
7.   INTERNAL_SIZE_T nextsize;    /* its size */
   
8.   int             nextinuse;   /* true if nextchunk is used */
   
9.   INTERNAL_SIZE_T prevsize;    /* size of previous contiguous chunk */
   
10.   mchunkptr       bck;         /* misc temp for linking */
    
11.   mchunkptr       fwd;         /* misc temp for linking */
    
12. 
    
13.   const char *errstr = NULL;
    
14.   int locked = 0;
    
15. 
    
16.   size = chunksize(p);
    
17. 
    
18.   ... ...
    
19. 
    
20.   /*
    
21.     If eligible, place chunk on a fastbin so it can be found
    
22.     and used quickly in malloc.
    
23.   */
    
24. 
    
25.   if ((unsigned long)(size) <= (unsigned long)(get_max_fast ())
    
26. 
    
27.     ... ...
    
28. 
    
29.     set_fastchunks(av);
    
30.     unsigned int idx = fastbin_index(size);
    
31.     fb = &fastbin (av, idx);
    
32. 
    
33.     mchunkptr fd;
    
34.     mchunkptr old = *fb;
    
35.     unsigned int old_idx = ~0u;
    
36.     do
    
37.       {
    
38.         /* Another simple check: make sure the top of the bin is not the
    
39.            record we are going to add (i.e., double free).  */
    
40.         if (__builtin_expect (old == p, 0))
    
41.           {
    
42.             errstr = "double free or corruption (fasttop)";
    
43.             goto errout;
    
44.           }

复制代码

为什么free(p1);free(p1);会"double free"，没有细看代码，我个人的理解是：两次取得的chunk_size一样，所以它认为是"double free"。
为什么中间加了一个free(p2)，就不会"double free"了，是因为再free(p1)的时候，chunk_size变了

因为p1,p2的大小都是10，所以它们都在fastbin里面分配；如果把p2设置成一个比较大的值，比如13B，free(p1);free(p2);free(p1);一样会"double free"，因为p2分配的chunk和p1不一样，不影响第二次free(p1)时候的判断

YEETA

楼上已经回答你的问题了

我只提一下，
你的Complex对象在调用operator-传递参数的时候有拷贝构造，此外还有（编译器自动生成的）operator=的调用，这两处都是bit-wise的拷贝
如果你的class要管理内存，最好实现所有的copy ctor 和 operator=，否则很容易踩地雷（比如double free）
此外，用引用的方式传递函数参数，避免不必要的构造和析构

tianhailong

那段代码里边是没有拷贝构造函数的，只有赋值回复 6# YEETA


   

何必抱怨

回复 7# tianhailong
编译器自动生成的。