C 错误 - free()：下一个大小无效（快速）

Posted 2023-02-21

【中文标题】C 错误 - free()：下一个大小无效（快速）

【英文标题】：C error - free(): invalid next size (fast)

【发布时间】：2012-10-23 18:57:29

【问题描述】：

我不确定为什么会出现以下错误。奇怪的是，这个错误在我使用 Mac OS X 时不会发生，但在我使用我的 Linux (Debian) 分区时会发生。

-----------
Empty Queue: 0 0 0 0 0 0 0 0 0 0 

---------------
Populated Queue: 5 3 1 7 6 3 2 1 4 4 

-------------
After Dequeue: 3 1 7 6 3 2 1 4 4 0 
    Datum: 5

*** glibc detected *** ./queue_demo: free(): invalid next size (fast): 0x0000000000c73010 ***
======= Backtrace: =========
/lib/x86_64-linux-gnu/libc.so.6(+0x75b76)[0x7fde5c98db76]
/lib/x86_64-linux-gnu/libc.so.6(cfree+0x6c)[0x7fde5c9928ac]
./queue_demo[0x40098d]
./queue_demo[0x4008d8]
/lib/x86_64-linux-gnu/libc.so.6(__libc_start_main+0xfd)[0x7fde5c936ead]
./queue_demo[0x4006d9]
======= Memory map: ========
00400000-00401000 r-xp 00000000 08:01 940937                             /home/dylan/Desktop/CST352_Gleason_Lab2/solution_1/queue_demo
00601000-00602000 rw-p 00001000 08:01 940937                             /home/dylan/Desktop/CST352_Gleason_Lab2/solution_1/queue_demo
00c73000-00c94000 rw-p 00000000 00:00 0                                  [heap]
7fde58000000-7fde58021000 rw-p 00000000 00:00 0 
7fde58021000-7fde5c000000 ---p 00000000 00:00 0 
7fde5c702000-7fde5c717000 r-xp 00000000 08:01 1079347                    /lib/x86_64-linux-gnu/libgcc_s.so.1
7fde5c717000-7fde5c917000 ---p 00015000 08:01 1079347                    /lib/x86_64-linux-gnu/libgcc_s.so.1
7fde5c917000-7fde5c918000 rw-p 00015000 08:01 1079347                    /lib/x86_64-linux-gnu/libgcc_s.so.1
7fde5c918000-7fde5ca95000 r-xp 00000000 08:01 1079316                    /lib/x86_64-linux-gnu/libc-2.13.so
7fde5ca95000-7fde5cc95000 ---p 0017d000 08:01 1079316                    /lib/x86_64-linux-gnu/libc-2.13.so
7fde5cc95000-7fde5cc99000 r--p 0017d000 08:01 1079316                    /lib/x86_64-linux-gnu/libc-2.13.so
7fde5cc99000-7fde5cc9a000 rw-p 00181000 08:01 1079316                    /lib/x86_64-linux-gnu/libc-2.13.so
7fde5cc9a000-7fde5cc9f000 rw-p 00000000 00:00 0 
7fde5cc9f000-7fde5ccbf000 r-xp 00000000 08:01 1079447                    /lib/x86_64-linux-gnu/ld-2.13.so
7fde5cea3000-7fde5cea6000 rw-p 00000000 00:00 0 
7fde5cebb000-7fde5cebe000 rw-p 00000000 00:00 0 
7fde5cebe000-7fde5cebf000 r--p 0001f000 08:01 1079447                    /lib/x86_64-linux-gnu/ld-2.13.so
7fde5cebf000-7fde5cec0000 rw-p 00020000 08:01 1079447                    /lib/x86_64-linux-gnu/ld-2.13.so
7fde5cec0000-7fde5cec1000 rw-p 00000000 00:00 0 
7fff13797000-7fff137b8000 rw-p 00000000 00:00 0                          [stack]
7fff137ff000-7fff13800000 r-xp 00000000 00:00 0                          [vdso]
ffffffffff600000-ffffffffff601000 r-xp 00000000 00:00 0                  [vsyscall]
Aborted

当我在下面编写的测试程序中调用队列结构中的destruct 函数时会发生此错误。

#include <time.h>
#include <stdio.h>
#include "Queue.h"

int main(int argc, char* argv[])

   // create a "queue" data structure
   Queue_t* my_queue = construct(10);

   // generate a random seed
   srand( (unsigned)time(NULL) );

   // display the empty queue
   printf("-----------\n");
   printf("Empty Queue: ");
   display(my_queue);
   printf("\n");

   // populate the queue with random numbers
   int i = 0;

   for(; i < my_queue->maximum_count; ++i)
      enqueue(my_queue, rand() % 10);

   printf("---------------\n");
   printf("Populated Queue: ");
   display(my_queue);
   printf("\n");

   // dequeue, print the current queue and the datum
   int datum = dequeue(my_queue);

   printf("-------------\n");
   printf("After Dequeue: ");
   display(my_queue);
   printf("\tDatum: %d\n\n", datum);

   // clean up memory
   destruct(my_queue);

   return 0;

这是我的数据结构：

#ifndef QUEUE_H
#define QUEUE_H

typedef struct Queue

   int  current_count;
   int  maximum_count;
   int  buffer[];       // queue uses an array
 Queue_t;


// routines to implement Queue-like functionality (FIFO)
// TODO: somehow encapsulate all these features in the struct itself.
//
Queue_t* construct(int buff_size);
void     destruct (Queue_t* queue);
void     display  (Queue_t* queue);
int      dequeue  (Queue_t* queue);
void     enqueue  (Queue_t* queue, const int datum);

#endif

实施：

#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include "Queue.h"

Queue_t* construct(int buff_size)

   Queue_t* queue = malloc(
      sizeof(Queue_t) + sizeof(int) * sizeof(Queue_t));

   assert(queue != NULL);
   queue->maximum_count = buff_size;
   queue->current_count = 0;
   memset(queue->buffer, 0, sizeof(int)*buff_size);

   return queue;


void destruct(Queue_t* queue)

   assert(queue != NULL);
   free(queue);  // error at this statement
   printf("Queue destroyed!\n");


void display(Queue_t* queue)

   int i = 0;

   for(; i < queue->maximum_count; ++i)
      printf("%d ", queue->buffer[i]);
   printf("\n");


void enqueue(Queue_t* queue, const int datum)

   assert(queue->current_count < queue->maximum_count);
   queue->buffer[queue->current_count] = datum;
   ++queue->current_count;



int dequeue(Queue_t* queue)

   int i = 1;
   int datum = queue->buffer[0];

   assert(queue->current_count > 0);

   for(; i < queue->maximum_count; ++i)
   
      queue->buffer[i-1] = queue->buffer[i];
      queue->buffer[i] = 0;
   

   --queue->current_count;

   return datum;

【参考方案1】：

这看起来像您损坏了 libc 内存分配函数使用的一些数据。在你的construct 函数中我们不应该改变

Queue_t* queue = malloc(
      sizeof(Queue_t) + sizeof(int) * sizeof(Queue_t));

到

Queue_t* queue = malloc(
          sizeof(Queue_t) + sizeof(int) * buff_size);

construct 中的以下行现在似乎由于为队列分配的内存量不正确而导致损坏。

 memset(queue->buffer, 0, sizeof(int)*buff_size);

当您将sizeof 运算符应用于具有灵活数组成员的结构时，只有灵活数组以外的字段构成结构的总大小，即其大小为 0。为此类结构分配内存时，您需要明确指定在结构末尾需要多少额外字节。

【讨论】：

术语狡辩：queue->buffer 不是“可变长度数组”，它是“灵活数组成员”。可变长度数组是一个不同的特性，它也是在 C99 中首次标准化的，它允许像 void func(int n, int arr[n]) 这样的东西。

【参考方案2】：

这两行应该匹配：

Queue_t* queue = malloc(sizeof(Queue_t) + sizeof(int) * buff_size);
memset(queue->buffer, 0, sizeof(int)*buff_size);

原始代码将分配 8+4*8 = 40 字节，而 memset 将清除 8+4*10 = 48 字节。这不一定显示为内存损坏，例如。 64 位 gnu malloc 会将内存块对齐到 16 字节边界，因此它实际上也会分配丢失的 8 个字节。

其他 malloc 实现可以并且将会分配更多，并且只是放置一些簿记数据（就在每个分配的单元之前 - 可能是链表或指向某些树状结构中的父块的指针）。覆盖此簿记将在释放时显示为“损坏的列表”。

【参考方案3】：

您还没有在

中定义数组的大小

typedef struct Queue

   int  current_count;
   int  maximum_count;
   int  buffer[];       // queue uses an array
 Queue_t;

这是仅针对 C99 定义的行为。对于以前的编译器，如果您希望缓冲区标记实际缓冲区的开始，请将其声明为 int buffer[1]; 并分配更大的缓冲区。

另外，好像你的分配不对：

Queue_t* queue = malloc(
    sizeof(Queue_t) + sizeof(int) * sizeof(Queue_t));

你到底要在这里分配什么？应该是Queue_t* queue = malloc(sizeof(Queue_t) + sizeof(int) * buf_size);

【讨论】：

灵活的数组成员在 C99 中被标准化，它们不是“未定义的行为”。

我以为是在构造函数中动态分配的……但是还是需要用一个元素的数组大小来声明？

@Dylan：不，你不需要用一个元素的数组大小来声明它，除非你需要支持旧的编译器。

@DietrichEpp 谢谢Dietrich，我忘了。编辑了答案

帖子的前半部分似乎在选择语言，作为一个类比，我可以说“class X public: ... ; 仅针对 C++ 定义行为，对于以前的编译器，您必须使用 struct X ...” .现在选择 C99 真的没什么奇怪的。