基本上,我正在使用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编译我的代码。我不理解错误消息,也不知道如何调试它。我应该怎么做才能释放指针数组?
答案 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
的实例生活在地址0x0000ff08
,0x0000ff18
,0x0000ff28
等处。
fft
的所有元素(直到fft[63]
)都发生相同的情况。在此示例中,comp
个实例fft[63][0]
,fft[63][1]
,fft[63][2]
等位于地址0x0001041c
,0x0001042c
,0x0001043c
等
现在考虑transpose
的作用。这样称呼:
transpose(&fft[0][0], len, len);
它像这样访问内存:
*((arr + (i*width)) + j)
arr
是第一个参数;其值为&fft[0][0]
,与fft[0]
相同,在我们的示例中为0x0000a000
。
width
是64。i
和j
介于0到63之间,具体取决于我们所处的循环迭代。假设它们位于63。
然后i*width
是63*64
是4032
,而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个子数组中的任何一个)。