在第 6731 次释放指针后双重释放或损坏

Question

问题是我的代码不是那么小，所以我将 post 只是它的片段，让我知道是否需要更多的代码才能使问题有效。

该程序使用具有各种排序算法（其中 18 个）的库，并将它们应用于未排序的数组。用户可以 select 数组大小和要测试的数组数量。

如果我select，例如，100 个元素的 100 个数组（18*100 = 1800 次算法对数组排序），代码有效。如果是另一种方式，即 1000 个数组，比如 10 个元素，1000 * 18 = 18 000 次排序，那么它会崩溃 "double free or corruption".

问题不在于问题出在哪里，而在于如何正确调试。

这是获取排序算法的函数指针（func）的函数，对元素进行排序，检查是否排序，添加适当的数据到 "Iteration" 结构，然后释放 "target"（要排序的数组）和 "Iter"（迭代结构）。

void test_sort(int* data, int size, sort_pointer func, Algorithm* Algo, int no)
{

    count_ncomp = 0;
    count_assign = 0;

    begin = clock();

    int* target = NULL;
    target = malloc(size * sizeof(int));
    if (!target)
        die("Memory error.");

    memcpy(target, data, size * sizeof(int));

    Iteration* Iter = malloc(sizeof(Iteration));
    Iter->no = no;

    if (is_sorted(func(target, size), size)) {
        end = clock();
        clocks = (double)(end - begin);
        time_spent = clocks / CLOCKS_PER_SEC;

        Iter->is_sorted = 1;
        Iter->comp_count = count_ncomp;
        Iter->assign_count = count_assign;
        Iter->clocks_total = clocks;
        Iter->time_spent = time_spent;
    } else {
        Iter->is_sorted = 0;
        debug("Not sorted, no: %d", no);

    };

    Algo->iterations[no - 1] = Iter;

    if (target == NULL) {
        debug("Target is NULL");
    }

    debug("before target1 free");

    debug("NO: %d", no);
    debug("pointer %p", target);

    free(target);
    free(Iter);
    debug("after target1 free");
    /*target = NULL;*/
}

这里是数据结构列表：

typedef struct {
    int no;
    int is_sorted;
    int comp_count;
    int assign_count;
    double clocks_total;
    double time_spent;
} Iteration;

typedef struct {
    char* type;
    char* complexity;
    int iter_count;
    int rank;
    int avg_comp;
    int avg_assign;
    double avg_clocks;
    double avg_time;
    Iteration* iterations[MAX_ITER];
} Algorithm;

程序开始：

Starting program: /home/riddle/tmp1/pratybos12
Mem used total: 0
How many arrays would you like to test? > 1000
What is the size of each array? > 10
What is the minimum number in each array? > 1
What is the maximum number in each array? > 10
How many repeating values there will be AT LEAST? > 0

这是运行程序：

DEBUG pratybos12.c:537: NO: 374
DEBUG pratybos12.c:538: pointer 0x55899fe8cb10
*** Error in `./pratybos12': double free or corruption (out): 0x000055899fe8cae0 ***
[1]    3123 abort (core dumped)  ./pratybos12

GDB 输出（我总是在 no=374 时崩溃）：

DEBUG pratybos12.c:542: after target1 free
DEBUG pratybos12.c:535: before target1 free
DEBUG pratybos12.c:537: NO: 374
DEBUG pratybos12.c:538: pointer 0x555555760b10

Breakpoint 1, test_sort (data=0x555555760ab0, size=10, func=0x555555558c04 <bubble_sort_b_and_c_and_e_and_f>, Algo=0x55555575ff00, no=374) at pratybos12.c:541
541         free(Iter);
(gdb) print Iter
 = (Iteration *) 0x555555760ae0
(gdb) c
Continuing.
*** Error in `/home/riddle/tmp1/pratybos12': double free or corruption (out): 0x0000555555760ae0 ***

Program received signal SIGABRT, Aborted.
0x00007ffff7a54860 in raise () from /usr/lib/libc.so.6

我读过许多 post 建议使用 Valgrind 对其进行测试，但是，运行 Valgrind，不会出现此崩溃。

我知道我 post 的信息很少，请让我了解更多需要的信息。

主要问题是如何调试。如何检查释放前的指针是否指向有效的东西，内存是否可访问等

Answer 1

函数中的这两行：

Algo->iterations[no - 1] = Iter;
...
free(Iter);

首先你让Algo->iterations[no - 1]指向同一个内存Iter指向两个，所以你有两个指针指向同一个内存。然后你释放内存，使两个指针都无效。

如果以后要使用指针，则不能释放它。

在第 6731 次释放指针后双重释放或损坏

double free or corruption after freeing a pointer on 6731st time

c

free

gdb

valgrind

pointers