C：将自由语句移动到单独的函数中会导致内存泄漏

我在C文件中有以下结构和初始化：

struct Lattice {
    int length;
    int** latt;
};

struct Lattice* Create(int size){
    struct Lattice latt;
    int i,j,k,l;

    latt.length = size;
    latt.latt = malloc(sizeof(int*) * latt.length);

    for(i=0; i<latt.length; i++){
        latt.latt[i] = malloc(sizeof(int) * latt.length);
    }

        for(j=0; j<latt.length; j++){
            for(k=0; k<latt.length; k++){
                latt.latt[j][k] = 0;
            }
        }

    struct Lattice* lattp = &latt;
    return lattp;

我得到了一个内存泄漏（根据Valgrind，它肯定丢失了40个字节，如果这有什么区别的话，还间接丢失了80个字节）

但是，如果我有相同的代码，除了将free语句（与Destroy中的语句相同）写入Create（并适当修改return语句），我就不会出现内存泄漏。为什么将free语句移动到单独的函数中会导致内存泄漏？

您的

Create（）

函数返回局部变量的地址：

struct Lattice* Create(int size){
    struct Lattice latt;  // this is a local variable - it only exists
                          // as long as the function Create() is running
    int i,j,k,l;

    latt.length = size;
    latt.latt = malloc(sizeof(int*) * latt.length);

    for(i=0; i<latt.length; i++){
        latt.latt[i] = malloc(sizeof(int) * latt.length);
    }

        for(j=0; j<latt.length; j++){
            for(k=0; k<latt.length; k++){
                latt.latt[j][k] = 0;
            }
        }

    struct Lattice* lattp = &latt;  // this takes the address of a local variable
    return lattp; // after this return, latt no longer exists
}

struct Lattice*创建（整数大小）{
struct Lattice latt；//这是一个局部变量-它只存在
//只要函数Create（）正在运行
int i，j，k，l；
板条长度=尺寸；
latt.latt=malloc（sizeof（int*）*latt.length）；
for（i=0；iYour
Create（）
函数返回局部变量的地址：

struct Lattice* Create(int size){
    struct Lattice latt;  // this is a local variable - it only exists
                          // as long as the function Create() is running
    int i,j,k,l;

    latt.length = size;
    latt.latt = malloc(sizeof(int*) * latt.length);

    for(i=0; i<latt.length; i++){
        latt.latt[i] = malloc(sizeof(int) * latt.length);
    }

        for(j=0; j<latt.length; j++){
            for(k=0; k<latt.length; k++){
                latt.latt[j][k] = 0;
            }
        }

    struct Lattice* lattp = &latt;  // this takes the address of a local variable
    return lattp; // after this return, latt no longer exists
}

struct Lattice*创建（整数大小）{
struct Lattice latt；//这是一个局部变量-它只存在
//只要函数Create（）正在运行
int i，j，k，l；
板条长度=尺寸；
latt.latt=malloc（sizeof（int*）*latt.length）；
对于（i=0；i）这可能是重复的，因为latt是堆栈变量。您不应该从函数返回堆栈变量的地址。除了局部变量问题，您不应该以这种方式分配2D数组。请参阅。@DanielJ:me标记为重复并不意味着您不应该问这个问题（由于您不知道问题的原因是什么，您不可能知道还有另一个问题解决了问题的原因）。正如您自己所指出的，这是为这个问题的未来观众准备的。或者换一种说法：在这种情况下，问题不是重复的，但答案是。与您的问题无关，但您可以在分配时使用
calloc
而不是
malloc
，而不是循环遍历每个元素并将其归零g空间。这可能是重复的，因为latt是堆栈变量。您不应该从函数返回堆栈变量的地址。除了局部变量问题，您不应该这样分配2D数组。请参阅。@DanielJ:me标记为重复并不意味着您不应该问这个问题（由于您不知道问题的原因是什么，您不可能知道还有另一个问题解决了问题的原因）。正如您自己所指出的，这是为这个问题的未来观众准备的。或者换一种说法：在这种情况下，问题不是重复的，但答案是。与您的问题无关，但您可以在分配时使用
calloc
而不是
malloc
，而不是循环遍历每个元素并将其归零g空间。谢谢！那么使用malloc为结构中的所有内容分配内存能解决我的问题吗？@DanielJ你可以选择
malloc（）
结构并返回指向它的指针，也可以返回结构本身。谢谢！使用malloc为结构中的所有内容分配内存能解决我的问题吗？@DanielJ您可以
malloc（）
结构并返回指向它的指针，也可以返回结构本身。
struct Lattice* Create(int size){
    struct Lattice latt;  // this is a local variable - it only exists
                          // as long as the function Create() is running
    int i,j,k,l;

    latt.length = size;
    latt.latt = malloc(sizeof(int*) * latt.length);

    for(i=0; i<latt.length; i++){
        latt.latt[i] = malloc(sizeof(int) * latt.length);
    }

        for(j=0; j<latt.length; j++){
            for(k=0; k<latt.length; k++){
                latt.latt[j][k] = 0;
            }
        }

    struct Lattice* lattp = &latt;  // this takes the address of a local variable
    return lattp; // after this return, latt no longer exists
}