代码之家 › 专栏 › 技术社区 › Kevin Meredith

C编程-返回指针释放

memory-leaks c

Kevin Meredith · 技术社区 · 15 年前

我有一个函数foo(),它分配内存并返回它。在我的主要功能结束时释放它是标准的做法吗?

char* foo(){
 char * p;

 p = malloc(sizeof(char) * 4); /* edit - thanks to msg board */
 p[0] = 'a';
 p[1] = 'b';
 p[2] = 'c';
 p[3] = '/0'; /* edit: thanks to the msg board. */

 return p;
}

int main(int argc, char *argv[])
{
 char * p2;

 p2 = foo();

 printf("%s", p2);    

 free(p2);

 return 0;
}

8 回复 | 直到 15 年前

Carl Norum 15 年前

结束时释放 main() 会是正确的事情,是的。不过,您可能会考虑使用NULL终止该字符串。可以说,更惯用的设计是对所有内存管理“在同一级别”进行设计。类似:

void foo(char *p)
{
  p[0] = 'a';
  p[1] = 'b';
  p[2] = 'c';
  p[3] = '\0';
}

int main(int argc, char **argv)
{
  char *p2 = malloc(4);
  foo(p2);
  printf("%s", p2);
  free(p2);
  return 0;
}

Paul Tomblin 15 年前

“标准惯例”,如果有这样的事情,就是一旦你完成了它就释放记忆。

我个人的信念是,即使你知道程序即将结束,你也应该释放内存,因为这是一个很好的实践,而且总有一天,不知何故,你会遇到一个环境,当程序退出时,它不会自动释放内存不正常。

Praveen S 15 年前

当不再需要对该变量的引用时,需要释放。但是,当程序退出时,分配给它的所有资源都将被释放。

是的,即使程序在下一行退出,当您使用完它时释放它也是一个很好的实践。

KevinDTimm 15 年前

当您分配3个字符时,为什么要使用malloc(sizeof(int)*3)?

Paul Michaels 15 年前

我本以为在同一个函数(在本例中是main())中分配和释放内存是更好的做法。

例如:

void foo(char *p)
{     
 p[0] = 'a';
 p[1] = 'b';
 p[2] = 'c';

 return ;
}

int main(int argc, char *argv[])
{
 char * p2;

 p = malloc(sizeof(int) * 3);
 foo(p2);

 printf("%s", p2);    

 free(p2);

 return 0;
}

In silico 15 年前

我不知道这是不是“标准惯例”,但是 free() 是必要的,否则你会泄露备忘录。

我有两个功能, new_foo() 和 delete_foo() ,像这样:

char* new_foo()
{
    char * p;
    p = malloc(sizeof(int) * 4);
    /* ... */
    return p;
}

void delete_foo(char* p)
{
    free(p);
}

int main()
{
    char * p2;
    p2 = new_foo();
    /* ... */
    delete_foo(p2);
    return 0;
}

在我看来,这“更有意义”。

wadesworld 15 年前

这样做的一个很好的理由是,您有匹配的malloc/free。如果代码被移动,程序员自然会寻找匹配的free来匹配malloc。如果它不在那里,它可能是一个困惑的来源(希望不会持续很长时间)。

简而言之,它使资源使用更加明显。

Gilles 'SO- stop being evil' 15 年前

一般规则是,一旦您发现不再需要内存,就应该立即释放内存。在特定情况下,在程序终止之前需要的内存有两个有效的视角。

保持简单:每 malloc 必须有相应的 free . 主要的好处是,如果您希望将独立程序转换为较大程序的组件,那么 main 会变成图书馆的电话 自由的 将是必需的。
保持简单:释放程序的资源是操作系统的工作。这是一个有效的管理策略。程序的内存是 region 当程序退出时在一个瞬间释放的内存。主要的好处是,您不需要跟踪每个分配的块,这有时会很困难(但之后您可能会考虑使用垃圾收集器)。