对我 malloc'd 不起作用的数据使用 free

Question

在我的程序开始时，我创建了这个结构：

struct directive {
    char gate[17];
    int n;
    int s;
    int *inputs;
    int *outputs;
    int *selectors;
};

这里包括我的整个主要 function：

int main(int argc, char** argv) {
    if (argc - 1 != 1) {
        printf("Invalid number of arguments\n");
        return 0;
    }

    //get file, return if invalid path
    FILE *file = fopen(argv[1], "r");
    if (!file) {
        printf("Invalid input\n");
        return 0;
    }

    //make temp of circuit with struct directive
    int scount = 0;
    struct directive* temp = NULL;
    int size = 2;
    int icount = 0;
    int ocount = 0;
    int tcount = 0;
    char dir[17];
    char **names;
    int *values;

    //get INPUT info
    fscanf(file, " %s", dir);
    fscanf(file, "%d", &icount);

    size += icount;
    names = malloc(size * sizeof(char *));
    names[0] = malloc(2 * sizeof(char));     //MALLOC
    strcpy(names[0], "0");
    names[1] = malloc(2 * sizeof(char));     //MALLOC
    strcpy(names[1], "1");

    int i;
    for (i = 0; i < icount; i++) {
        names[i + 2] = malloc(17 * sizeof(char));
        fscanf(file, "%*[: ]%16s", names[i + 2]);
    }

    //get OUTPUT info
    fscanf(file, " %s", dir);
    fscanf(file, "%d", &ocount);
    size += ocount;
    names = realloc(names, size * sizeof(char *));
    for (i = 0; i < ocount; i++) {
        names[i + icount + 2] = malloc(17 * sizeof(char));
        fscanf(file, "%*[: ]%16s", names[i + icount + 2]);
    }

    //get temp
    struct directive step;
    while (!feof(file)) {
        int numInputs = 2, numOutputs = 1;

        int sc = fscanf(file, " %s", dir);
        if (sc != 1) {
            break;
        }
        scount++;
        step.n = 0;
        step.s = 0;
        strcpy(step.gate, dir);

        if (strcmp(dir, "NOT") == 0) {
            numInputs = 1;
        }
        if (strcmp(dir, "PASS") == 0) {
            numInputs = 1;
        }
        if (strcmp(dir, "DECODER") == 0) {
            fscanf(file, "%d", &numInputs);
            step.n = numInputs;
            numOutputs = pow(2, numInputs);
        }
        if (strcmp(dir, "MULTIPLEXER") == 0) {
            fscanf(file, "%d", &numInputs);
            step.s = numInputs;
            numInputs = pow(2, numInputs);
        }

        step.inputs = malloc(numInputs * sizeof(int));
        step.outputs = malloc(numOutputs * sizeof(int));
        step.selectors = malloc(step.s * sizeof(int));

        char v[17];
        for (i = 0; i < numInputs; i++) {
            fscanf(file, "%*[: ]%16s", v);
            step.inputs[i] = indexOf(size, names, v);
        }

        for (i = 0; i < step.s; i++) {
            fscanf(file, "%*[: ]%16s", v);
            step.selectors[i] = indexOf(size, names, v);
        }

        for (i = 0; i < numOutputs; i++) {
            fscanf(file, "%*[: ]%16s", v);
            int idx = indexOf(size, names, v);
            if (idx == -1) {
                size++;
                tcount++;
                names = realloc(names, size * sizeof(char *));
                names[size - 1] = malloc(17 * sizeof(char));
                strcpy(names[size - 1], v);
                step.outputs[i] = size - 1;
            }
            else {
                step.outputs[i] = idx;
            }
        }

        //add step to list of temp
        if (!temp) {
            temp = malloc(sizeof(struct directive));
        } else {
            temp = realloc(temp, scount * sizeof(struct directive));
        }
        temp[scount - 1] = step;


    }

    // initialize values array
    values = malloc(size * sizeof(int));
    resetValues(size, values);

    while(1 < 2) {
        //print inputs
        for (i = 0; i < icount; i++) {
            printf("%d ", values[i + 2]);
        }
        printf("|");

        //run through temp, calculate outputs
        for (i = 0; i < scount; i++) {
            struct directive step = temp[i];
            if (strcmp(step.gate, "NOT") == 0) {
                NOT(values, step.inputs[0], step.outputs[0]);
            }
            if (strcmp(step.gate, "AND") == 0) {
                AND(values, step.inputs[0], step.inputs[1], step.outputs[0]);
            }
            if (strcmp(step.gate, "OR") == 0) {
                OR(values, step.inputs[0], step.inputs[1], step.outputs[0]);
            }
            if (strcmp(step.gate, "NAND") == 0) {
                NAND(values, step.inputs[0], step.inputs[1], step.outputs[0]);
            }
            if (strcmp(step.gate, "NOR") == 0) {
                NOR(values, step.inputs[0], step.inputs[1], step.outputs[0]);
            }
            if (strcmp(step.gate, "XOR") == 0) {
                XOR(values, step.inputs[0], step.inputs[1], step.outputs[0]);
            }
            if (strcmp(step.gate, "PASS") == 0) {
                PASS(values, step.inputs[0], step.outputs[0]);
            }
            if (strcmp(step.gate, "DECODER") == 0) {
                DECODER(values, step.n, step.inputs, step.outputs);
            }
            if (strcmp(step.gate, "MULTIPLEXER") == 0) {
                MUX(values, step.s, step.inputs, step.selectors, step.outputs[0]);
            }

        }

        //print outputs
        for (i = 0; i < ocount; i++) {
            printf(" %d", values[icount + i + 2]);
        }
        printf("\n");

        if (!incrementInputs(values, icount)) {
            break;
        }

    }


    for (i = 0; i < icount; i++) {
        free(names[i + 2]);
    }

    for (i = 0; i < ocount; i++) {
        free(names[i + icount + 2]);
    }

    free(step.inputs);
    free(step.outputs);
    free(step.selectors);

    free(names[0]);
    free(names[1]);

    free(values);
    free(temp);

    return 0;
}

我遇到的问题是在编译时，我的地址清理程序告诉我，我在第 203 行和第 204 行有一个 memory 泄漏，它们是以下 malloc：

    names = realloc(names, size * sizeof(char *));
    names[size - 1] = malloc(17 * sizeof(char));

你可以看到我释放了我分配的三行，那么它实际上没有释放的原因是什么？ 由于我在 main 之后做了其他事情，我是否必须循环使用某些内容并免费使用？

Answer 1

您在循环中分配 memory 但仅释放您在上次迭代中获得的内容：

   ...
   while (!feof(file)) {
       ...
       step.inputs = malloc(numInputs * sizeof(int));
       step.outputs = malloc(numOutputs * sizeof(int));
       step.selectors = malloc(step.s * sizeof(int));
       ...
   }
   ...
   free(step.inputs);
   free(step.outputs);
   free(step.selectors);
   ...

Answer 2

由于while (.feof(file)) {... }循环的最终迭代，这组调用仅释放step的最后保存值。

free(step.inputs);
free(step.outputs);
free(step.selectors);

每次迭代， step都会被复制到temp的一个元素中，因此您必须在释放temp之前释放每个元素的成员。

for (int i = 0; i < scount; i++) {
    free(temp[i].inputs);
    free(temp[i].outputs);
    free(temp[i].selectors);
}

Answer 3

其他人已经指出了主要问题，所以我不会重复它们，但我想提供一些提示以使分配更安全一些。

当你malloc()并需要提供数据的大小时，使用sizeof(type)并没有错，但是如果你输入错误的类型，就像一个简单的错字一样，你会得到错误的 memory 数量。 即使您没有犯任何错误，但如果您稍后更改指针类型，它也会对您不利。 编译器不会检查您给malloc()的大小是否正确（实际上不能），因此您不会收到任何有关为错误类型分配大小的位置的警告。

因此，在分配中，例如

    names = malloc(size * sizeof(char *));
    names[0] = malloc(2 * sizeof(char));
    names[i + 2] = malloc(17 * sizeof(char));
    step.inputs = malloc(numInputs * sizeof(int));
    step.outputs = malloc(numOutputs * sizeof(int));
    step.selectors = malloc(step.s * sizeof(int));

所有sizeof()都是错误的潜在藏身之处。

相反，您可以从分配分配的指针获取大小。 当然，并非总是如此，有时您需要分配一些东西而您没有分配给的变量-将分配的 memory 发送到 function 或类似的东西，但 99% 的时间，如果您是 Z2024EDA2A3DC1D327B正在分配给一个变量。 您还可以使用sizeof获取变量指向的类型的大小。 sizeof运算符有两种形式。 一个接受类型sizeof(type)和一个接受表达式sizeof expressions或sizeof(expression) ； 括号在这里是可选的。

您可以将上面的分配更改为：

    names = malloc(size * sizeof *names);
    names[0] = malloc(2 * sizeof *names[0])
    names[i + 2] = malloc(17 * sizeof *names[i + 2])
    step.inputs = malloc(numInputs * sizeof *step.inputs);
    step.outputs = malloc(numOutputs * sizeof *step.outputs);
    step.selectors = malloc(step.s * sizeof *step.selectors);

您需要在此处取消引用该变量，否则您将获得指针的大小而不是它指向的内容，但不必担心此取消引用。 编译器不会发出实际取消引用的代码，考虑到指针尚未初始化，这在任何情况下都是灾难性的。 不，指针只是计算出表达式的类型并从那里获取大小。 这样，您要为其分配空间的分配和类型保持一致。

另一件事是你做的realloc() ：

    names = realloc(names, size * sizeof(char *));

诚然，它不太可能失败，但如果失败了， realloc()会返回NULL ，如果失败了，它还没有释放它的输入指针。 如果此realloc()失败，您将在names中包含NULL ，并且您将泄露names之前指向的 memory。

由于这个原因，您通常不应将realloc()的结果直接分配给输入指针。 最好分配给一个临时变量，检查是否分配失败，如果没有，那么你可以分配给你想要保存结果的变量。

    char **tmp = realloc(names, size * sizeof *tmp);
    if (!tmp) abort(); // handle alloc failure
    names = tmp;

当然，这取决于您是否计划处理分配失败。 我只是在这里abort() ，你可以做同样的事情而不分配给tmp变量

    names = realloc(names, size * sizeof *tmp);
    if (!names) abort(); // handle alloc failure

如果您在桌面上运行，分配错误不太可能成为问题，并且使用一些适当的错误消息终止程序是一个简单的修复，可能没问题。