不知道如何正确使用malloc（）和free（）

我编写这个函数是为了计算链表的长度。我仍然在通过玩指针来学习指针。我知道我可以在函数中使用一个简单的len变量，但我想学习动态内存分配的基础知识。为什么即使列表中的元素很少，长度也始终为0？什么时候应该调用

free（）

？

一旦调用了内存，就不能使用它。所以

int listLength(struct node *r) { 

    int *len = (int *)malloc(sizeof(int));
    if(!r) { 
       free(len);
       return *len; 
    }

    while(r) { 
         r = r->next; 
           *len += 1; 
    }
    free(len)
    return *len; 
}

是错误和未定义的行为

相反，您可以使用局部变量保存该值并

返回它

还有,FWIW,

   free(len);
   return *len;

在上面的代码中，您试图使用未初始化的
*len
作为返回值。即使没有
free（）
ing，也不应该这样做

此外，在使用返回的指针之前，应始终检查
malloc（）
ve是否成功

修改后的版本：

int *len = (int *)malloc(sizeof(int));
    if(!r) { 
       free(len);
       return *len; 
    }


编辑：

在您的情况下，根本不需要使用动态内存分配。正如Barak Manos先生和WhozCraig先生所建议的，只有在编译时不知道内存需求时，才应该使用动态内存分配。否则，一般来说，静态（编译时）内存分配就可以了

更好、更干净的代码处理方法

int listLength(struct node *r) { 

    int *lenp = malloc(sizeof(int));
    int len = 0;

    if (!lenp)     //check malloc success
        exit(-1);    


    *lenp = len;

    if(!r) { 
       free(lenp);
       return len; 
    }

    while(r) { 
         r = r->next; 
           *lenp += 1; 
    }

    len = *lenp;
    free(lenp);
    return len; 
}

一旦
释放（）
内存，就无法使用它。所以

int listLength(struct node *r) { 

    int *len = (int *)malloc(sizeof(int));
    if(!r) { 
       free(len);
       return *len; 
    }

    while(r) { 
         r = r->next; 
           *len += 1; 
    }
    free(len)
    return *len; 
}

是错误和未定义的行为

相反，您可以使用局部变量保存该值并
返回它

还有,FWIW,

   free(len);
   return *len;

在上面的代码中，您试图使用未初始化的
*len
作为返回值。即使没有
free（）
ing，也不应该这样做

此外，在使用返回的指针之前，应始终检查
malloc（）
ve是否成功

修改后的版本：

int *len = (int *)malloc(sizeof(int));
    if(!r) { 
       free(len);
       return *len; 
    }


编辑：

在您的情况下，根本不需要使用动态内存分配。正如Barak Manos先生和WhozCraig先生所建议的，只有在编译时不知道内存需求时，才应该使用动态内存分配。否则，一般来说，静态（编译时）内存分配就可以了

更好、更干净的代码处理方法

int listLength(struct node *r) { 

    int *lenp = malloc(sizeof(int));
    int len = 0;

    if (!lenp)     //check malloc success
        exit(-1);    


    *lenp = len;

    if(!r) { 
       free(lenp);
       return len; 
    }

    while(r) { 
         r = r->next; 
           *lenp += 1; 
    }

    len = *lenp;
    free(lenp);
    return len; 
}

一旦
释放（）
内存，就无法使用它。所以

int listLength(struct node *r) { 

    int *len = (int *)malloc(sizeof(int));
    if(!r) { 
       free(len);
       return *len; 
    }

    while(r) { 
         r = r->next; 
           *len += 1; 
    }
    free(len)
    return *len; 
}

是错误和未定义的行为

相反，您可以使用局部变量保存该值并
返回它

还有,FWIW,

   free(len);
   return *len;

在上面的代码中，您试图使用未初始化的
*len
作为返回值。即使没有
free（）
ing，也不应该这样做

此外，在使用返回的指针之前，应始终检查
malloc（）
ve是否成功

修改后的版本：

int *len = (int *)malloc(sizeof(int));
    if(!r) { 
       free(len);
       return *len; 
    }


编辑：

在您的情况下，根本不需要使用动态内存分配。正如Barak Manos先生和WhozCraig先生所建议的，只有在编译时不知道内存需求时，才应该使用动态内存分配。否则，一般来说，静态（编译时）内存分配就可以了

更好、更干净的代码处理方法

int listLength(struct node *r) { 

    int *lenp = malloc(sizeof(int));
    int len = 0;

    if (!lenp)     //check malloc success
        exit(-1);    


    *lenp = len;

    if(!r) { 
       free(lenp);
       return len; 
    }

    while(r) { 
         r = r->next; 
           *lenp += 1; 
    }

    len = *lenp;
    free(lenp);
    return len; 
}

一旦
释放（）
内存，就无法使用它。所以

int listLength(struct node *r) { 

    int *len = (int *)malloc(sizeof(int));
    if(!r) { 
       free(len);
       return *len; 
    }

    while(r) { 
         r = r->next; 
           *len += 1; 
    }
    free(len)
    return *len; 
}

是错误和未定义的行为

相反，您可以使用局部变量保存该值并
返回它

还有,FWIW,

   free(len);
   return *len;

在上面的代码中，您试图使用未初始化的
*len
作为返回值。即使没有
free（）
ing，也不应该这样做

此外，在使用返回的指针之前，应始终检查
malloc（）
ve是否成功

修改后的版本：

int *len = (int *)malloc(sizeof(int));
    if(!r) { 
       free(len);
       return *len; 
    }


编辑：

在您的情况下，根本不需要使用动态内存分配。正如Barak Manos先生和WhozCraig先生所建议的，只有在编译时不知道内存需求时，才应该使用动态内存分配。否则，一般来说，静态（编译时）内存分配就可以了

更好、更干净的代码处理方法

int listLength(struct node *r) { 

    int *lenp = malloc(sizeof(int));
    int len = 0;

    if (!lenp)     //check malloc success
        exit(-1);    


    *lenp = len;

    if(!r) { 
       free(lenp);
       return len; 
    }

    while(r) { 
         r = r->next; 
           *lenp += 1; 
    }

    len = *lenp;
    free(lenp);
    return len; 
}

一般情况下：在拥有
free（）
'd内存块后，您再也不能访问它了。想想看，你把那个街区让开了。它不再是你的了

因此，只有当您不想再访问一个块时，才必须释放它。这是一条基本的规则；永远不要打破它

对于这个例子，正如其他人所说，实际上根本不需要使用动态内存

哦，还有：你真的不应该投马洛克的结果！它返回
void*
，可以将其分配给任何其他指针类型。阅读，第6.5.16.1节。
一般来说：在
释放（）内存块后，您不得再访问它。想想看，你把那个街区让开了。它不再是你的了

因此，只有当您不想再访问一个块时，才必须释放它。这是一条基本的规则；永远不要打破它

对于这个例子，正如其他人所说，实际上根本不需要使用动态内存

哦，还有：你真的不应该投马洛克的结果！它返回
void*
，可以将其分配给任何其他指针类型。阅读，第6.5.16.1节。
一般来说：在
释放（）内存块后，您不得再访问它。想想看，你把那个街区让开了。它不再是你的了

因此，只有当您不想再访问一个块时，才必须释放它。这是一条基本的规则；永远不要打破它

对于这个例子，正如其他人所说，实际上根本不需要使用动态内存

哦，还有：你真的不应该投马洛克的结果！它回来了