c - 为什么这会引入内存泄漏？

Question

我正在为 C 中的集合覆盖问题实现蚁群优化。在我的代码中，我发现了一个导致内存泄漏的函数。我很确定这个函数是内存泄漏的原因，因为我已经通过测试排除了其他函数。只是，我不明白为什么这个函数会引入内存泄漏。

为了理解这个函数，我将描述 Ant首先构造。 Ant结构看起来像这样:

struct Ant {
    int* x;
    int* y;
    int fx;
    int** col_cover;
    int* ncol_cover;
    int un_rows;
    double* pheromone;
}

typedef struct Ant ant_t;

此结构中的指针(例如 x 、 y 、 col_cover 等)使用 malloc 进行初始化并在程序结束时释放。现在，导致内存泄漏的函数如下:

void localSearch(ant_t* ant) {
    int improvement = 1;
    ant_t* antcpy = (ant_t*) malloc(sizeof(ant_t));
    initAnt(antcpy);
    copyAnt(ant, antcpy);
    while (improvement) {
        improvement = 0;
        for (int i = 0; i < inst->n; i++) {
            if (antcpy->x[i]) {
                removeSet(inst, antcpy, i);
                while (!isSolution(antcpy)) {
                    constructSolution(antcpy);
                }
                if (antcpy->fx < ant->fx) {
                    copyAnt(antcpy, ant);
                    improvement = 1;
                    eliminate(ant);
                } else {
                    copyAnt(ant, antcpy);
                }
            }
        }
    }
    free((void*) antcpy);
}

首先，我创建了 Ant 的另一个实例结构(antcpy)，使用initAnt功能。 copyAnt函数做一个深拷贝 Ant结构到另一个Ant结构。我进行深拷贝的原因如下；我正在更改 antcpy然后将其与 ant 进行比较.如果结果更好(antcpy->fx < ant->fx)，ant被 antcpy 取代.如果结果更糟，antcpy恢复到 ant 的值.

这些函数如下:

void initAnt(ant_t* ant) {
    ant->x = (int*) malloc(inst->n * sizeof(int));
    ant->y = (int*) malloc(inst->m * sizeof(int));
    ant->col_cover = (int**) malloc(inst->m * sizeof(int*));
    ant->ncol_cover = (int*) malloc(inst->m * sizeof(int));
    ant->pheromone = (double*) malloc(inst->n * sizeof(double));
    for (int i = 0; i < inst->m; i++) {
        ant->col_cover[i] = (int*) malloc(inst->ncol[i] * sizeof(int));
    }
}

void copyAnt(ant_t* from, ant_t* to) {
    to->fx = from->fx;
    to->un_rows = from->un_rows;
    for (int i = 0; i < inst->n; i++) {
        to->x[i] = from->x[i];
        to->pheromone[i] = from->pheromone[i];
    }
    for (int i = 0; i < inst->m; i++) {
        to->y[i] = from->y[i];
        to->ncol_cover[i] = from->ncol_cover[i];
        for (int j = 0; j < inst->ncol[i]; j++) {
            to->col_cover[i][j] = from->col_cover[i][j];
        }
    }
}

我真的不明白为什么这段代码会导致内存泄漏，因为我释放了 antcpy在 localSearch 的末尾功能。那么，为什么这段代码会引入内存泄漏，我该如何修复它？

Answer 1

您必须实现一个函数 freeAnt，在 free((void*) antcpy); 之前将释放在 initAnt 中分配的所有内存。

void freeAnt(ant_t* ant) {
    for (int i = 0; i < inst->m; i++) {
        free(ant->col_cover[i]);
    }
    free(ant->pheromone);
    free(ant->ncol_cover);
    free(ant->col_cover);
    free(ant->y);
    free(ant->x);
}