Question

问题是我的代码不是那么小，所以我只发布它的片段，如果问题需要更多的话，请告诉我。

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

如果我选择，例如，1000个元素的100个阵列（18 * 100 = 1800次算法对数组进行排序），代码就可以工作。如果是另一种方式，即说10个元素的1000个数组，1000 * 18 = 18 000个排序，那么它会与＆＃34;双重自由或腐败＆＃34;崩溃。

问题不在于问题所在，而在于，如何正确调试问题。

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

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
$3 = (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

我已经阅读了许多建议用Valgrind进行测试的帖子，然而，与Valgrind一起运行，这种崩溃不会出现。

我知道我发布了很少的信息，请让我了解更多信息。

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

Answer 1

这两行来自函数：

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

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

如果您想稍后使用指针，则无法释放它。

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

1 个答案: