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);
}

为什么会引入内存泄漏？

1 个答案: