./a.out中的错误:free():释放动态分配的2D结构数组时,下一个大小(正常)无效

时间:2019-03-15 16:02:26

标签: c arrays struct free calloc

基本上,我正在使用calloc()创建2D结构数组。然后,我利用该数组,释放了分配的空间,而释放它时,我得到的是“双重释放或损坏(!prev)”。代码是用C语言编写的。


代码:

#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <fcntl.h>
#include <malloc.h>
#include <unistd.h>
#include <string.h>
#include <float.h>

typedef struct  complex_num{
    double real;
    double imag;
}comp;

void transpose(comp *arr, int height, int width);
void change(comp *arr, int width);

void main(){    
        int width = 64, height = 64;

        int len = width;
        comp *fft[len];
        for(int i=0; i<len; i++){
                fft[i] = (comp *)calloc(len, sizeof(comp));
        }


        for (int scan=0;scan<height;scan++){
                for (int pix=0;pix<width;pix++){
                        fft[scan][pix].real = 1.0;
                        fft[scan][pix].imag = 0.0;
                }
                change(&fft[scan][0], len);
        }
        transpose(&fft[0][0], len, len);
        for(int i=0;i<len;i++){
                change(&fft[i][0], len);
        }
        transpose(&fft[0][0], len, len); 
        for(int i=0;i<len;i++){
                free(fft[i]);
        }
}
void transpose(comp *arr, int height, int width){
        comp var;
        for(int i=0;i<height;i++){
                for(int j=0;j<width;j++){
                        if(j>i){
                                var = *((arr + (i*width)) + j);
                                *((arr + i*width) + j) = *((arr + j*width) + i);
                                *((arr + j*width) + i) = var;
                        }
                }
        }
}

void change(comp *arr, int width){
        for(int i=0; i<width; i++){
                (arr + i)->real = 5.0;
                (arr + i)->imag = 6.9;
        }
}

错误消息:

    *** Error in `./a.out': double free or corruption (!prev): 0x0000000002095010 ***
======= Backtrace: =========
/lib/x86_64-linux-gnu/libc.so.6(+0x777e5)[0x7f05108a77e5]
/lib/x86_64-linux-gnu/libc.so.6(+0x8037a)[0x7f05108b037a]
/lib/x86_64-linux-gnu/libc.so.6(cfree+0x4c)[0x7f05108b453c]
./a.out[0x400880]
/lib/x86_64-linux-gnu/libc.so.6(__libc_start_main+0xf0)[0x7f0510850830]
./a.out[0x400509]
======= Memory map: ========
00400000-00401000 r-xp 00000000 00:00 467935                     /path/to/a.out
00600000-00601000 r--p 00000000 00:00 467935                     /path/to/a.out
00601000-00602000 rw-p 00001000 00:00 467935                     /path/to/a.out
02095000-020b6000 rw-p 00000000 00:00 0                          [heap]
7f050c000000-7f050c021000 rw-p 00000000 00:00 0
7f050c021000-7f0510000000 ---p 00000000 00:00 0
7f0510610000-7f0510626000 r-xp 00000000 00:00 360788             /lib/x86_64-linux-gnu/libgcc_s.so.1
7f0510626000-7f0510825000 ---p 00000016 00:00 360788             /lib/x86_64-linux-gnu/libgcc_s.so.1
7f0510825000-7f0510826000 rw-p 00015000 00:00 360788             /lib/x86_64-linux-gnu/libgcc_s.so.1
7f0510830000-7f05109f0000 r-xp 00000000 00:00 360750             /lib/x86_64-linux-gnu/libc-2.23.so
7f05109f0000-7f05109f9000 ---p 001c0000 00:00 360750             /lib/x86_64-linux-gnu/libc-2.23.so
7f05109f9000-7f0510bf0000 ---p 000001c9 00:00 360750             /lib/x86_64-linux-gnu/libc-2.23.so
7f0510bf0000-7f0510bf4000 r--p 001c0000 00:00 360750             /lib/x86_64-linux-gnu/libc-2.23.so
7f0510bf4000-7f0510bf6000 rw-p 001c4000 00:00 360750             /lib/x86_64-linux-gnu/libc-2.23.so
7f0510bf6000-7f0510bfa000 rw-p 00000000 00:00 0
7f0510c00000-7f0510c25000 r-xp 00000000 00:00 360690             /lib/x86_64-linux-gnu/ld-2.23.so
7f0510c25000-7f0510c26000 r-xp 00025000 00:00 360690             /lib/x86_64-linux-gnu/ld-2.23.so
7f0510e25000-7f0510e26000 r--p 00025000 00:00 360690             /lib/x86_64-linux-gnu/ld-2.23.so
7f0510e26000-7f0510e27000 rw-p 00026000 00:00 360690             /lib/x86_64-linux-gnu/ld-2.23.so
7f0510e27000-7f0510e28000 rw-p 00000000 00:00 0
7f0510e30000-7f0510e31000 rw-p 00000000 00:00 0
7f0510e40000-7f0510e41000 rw-p 00000000 00:00 0
7f0510e50000-7f0510e51000 rw-p 00000000 00:00 0
7f0510e60000-7f0510e61000 rw-p 00000000 00:00 0
7fffc47c7000-7fffc4fc7000 rw-p 00000000 00:00 0                  [stack]
7fffc5242000-7fffc5243000 r-xp 00000000 00:00 0                  [vdso]

已中止(核心被丢弃)

我正在使用GCC版本5.4.0编译我的代码。我不理解错误消息,也不知道如何调试它。我应该怎么做才能释放指针数组?

1 个答案:

答案 0 :(得分:3)

transpose公然访问数组范围之外的元素。

fft中的

main是一个指针数组。每个指针都被初始化为指向动态分配的内存块(通过calloc)。

在内存中看起来像这样:

                                   0            1                  63
fft:  0 [ 0x0000a000 ] ----> [ real; imag | real; imag | ... | real; imag ]
      1 [ 0x0000ff08 ] ----> [ real; imag | real; imag | ... | real; imag ]
      .
      .
      .
     63 [ 0x0001041c ] ----> [ real; imag | real; imag | ... | real; imag ]

fft有64个元素,每个元素都是一个指针。在此示例中,fft[0]的值为0x0000a000,在该地址处还有另一个64元素数组(由calloc创建),该数组存储类型为comp(是2元素结构)。

因此,*fft[0]是第一个comp结构(在地址0x0000a000),*fft[1]是第二个comp结构(在地址0x0000a010 ),*fft[2]是第三个comp结构(位于地址0x0000a020),依此类推。每个comp结构占用16个字节,因此地址增加16(0x10)。 fft[0]的最后一个元素fft[0][63]位于地址0x0000a3f0

fft[1]是第二个指针,指向第二个(不相关的)内存块(也由calloc创建)。在此示例中,comp的实例生活在地址0x0000ff080x0000ff180x0000ff28等处。

fft的所有元素(直到fft[63])都发生相同的情况。在此示例中,comp个实例fft[63][0]fft[63][1]fft[63][2]等位于地址0x0001041c0x0001042c0x0001043c

现在考虑transpose的作用。这样称呼:

transpose(&fft[0][0], len, len);

它像这样访问内存:

*((arr + (i*width)) + j)

arr是第一个参数;其值为&fft[0][0],与fft[0]相同,在我们的示例中为0x0000a000

width是64。ij介于0到63之间,具体取决于我们所处的循环迭代。假设它们位于63。

然后i*width63*644032,而arr + 4032是指向数组的4033rd元素的指针。可是等等!没有这样的元素。 arr只有64个元素。

我们现在位于内存地址0x00019c00内,该地址远远超出fft[0]的范围(回想一下,它的元素只能到达地址0x000a3f0)。

但是我们还没有完成:向此指针添加j(63),得到0x00019ff0。这个指针就是我们用*取消引用的指针。

如果我们使用数组表示法编写了此操作,看起来就像

arr[i*width + j]

这显然表明我们正在访问64个元素的数组的元素4095。

transpose甚至写信给这个地址:

*((arr + i*width) + j) = ...

这会修改程序不拥有的内存,从而破坏malloc / calloc / free使用的内部数据结构。这就是错误消息double free or corruption的含义:您的代码破坏了free所需的数据,这可以通过两次释放同一指针(“两次释放”)或仅在结束时写入内存来发生数组中的代码(如代码中一样)。


要修复您的代码,请将transpose更改为

void transpose(comp **arr, int height, int width) {
    for (int i = 0 ; i < height; i++) {
        for (int j=0; j < width; j++) {
            if (j > i) {
                comp var = arr[i][j];
                arr[i][j] = arr[j][i];
                arr[j][i] = var;
            }
        }
    }
}

并命名为

transpose(fft, len, len);

通过这种方式,您不仅可以传递第一个子数组的地址,而且可以传递中间指针数组的地址(从而可以访问64个子数组中的任何一个)。