Question

当将char *作为参数传递给函数时，被调用的函数是否应该对该字符串执行free？否则，数据将“丢失”，程序将泄漏数据。或者编译器以特殊方式处理char *以避免每个人不得不一直处于空闲状态并自动删除它超出范围？我将“字符串”传递给函数，因此不将实例传递给已存在的char *。或者应该使用char []代替？只是觉得为参数输入设置固定限制是如此愚蠢。

Answer 1

记住这个简单的原则：“总是在你分配它的同一级别中释放内存”。换句话说，函数永远不应该尝试释放它本身没有分配的内存。一个简短的例子来澄清这一点：

#include "graphics.h"

// The graphics API will get a Canvas object for us. This may be newly allocated
// or one from a pool of pre-allocated objects. 
Canvas* canvas = graphics_get_canvas (); 

// If draw_image () frees canvas, that violates the above principle.
// The behavior of the program will be unspecified. So, just draw the image
// and return.
draw_image (canvas); 

// This is also a violation.
// free (canvas) ; 

// The right thing to do is to give back the Canvas object to the graphics API
// so that it is freed at the same 'level' where it was allocated. 
graphics_return_canvas (canvas);

请注意，该函数未命名为graphics_free_canvas ()或类似名称，因为API可以选择释放它或通过将其返回池来重复使用它。关键是，假设我们没有创建的资源的所有权是一种非常糟糕的编程习惯，除非我们另有特别说明。

Answer 2

听起来你在询问这种用法：

void foo(char* str);
foo("test string");

这是一个特例; "test string"是存储在可执行文件中的字符串表中的常量字符串，不需要被释放。 foo实际上应该使用const char*来说明这一点，并且在C ++中不推荐允许将字符串文字存储在非常量char*中

Answer 3

该函数是否应该free取决于拥有字符串的人。此代码完全有效，不会导致任何内存泄漏：

int main()
{
  char* s = malloc(.....);
  f(s);
  free(s);
}

free可以在函数f内执行，如果它取得字符串的所有权。但请注意，这是危险的，因为您假设传递给函数f的字符串始终使用malloc或相关函数在堆上分配。如果用户将指针传递给堆栈上分配的字符串，则程序将表现得不可预测。

总的来说，编译器不对字符串的内存管理进行任何特殊处理。从编译器的角度来看，它只是一堆字符。

Answer 4

似乎你习惯了OOP风格。我不喜欢OOP，对我来说如果我在分配后获得一个对象的副本会很奇怪。在这种情况下，字符串在内存中的某个位置，其地址作为char *发送，而不是整个字符串。另外，请注意，您只能释放（）仅由malloc（）返回的指针，并且只能释放一次。

Answer 5

有时API会期望一个已分配的缓冲区及其最多为函数的所有者，该函数调用该api来释放它。

myFunc()
{
char *error = malloc(<max size of error string>);
foo(error);
//Free the pointer here
free(error);

}

像GLIB api这样的API期望指向声明变量的地址

myFunc()
{
GError *error;

glib_api(&error);
if (error)
{
printf("Error %s", error-> message);
// can use  glib API to free if error is NON NULL but message is allocated by GLIB API
g_error_free(error);
}
}

因此，即使您没有为变量分配内存，也需要在使用标准库时进行释放。

分配的内存如果没有释放，将导致多进程环境中的内存减少，从而降低系统性能。

Answer 6

使用普通char *，我建议始终使用调用者“拥有”字符串的策略编写代码，如果malloc获取，则负责释放它。另一方面，人们当然可以设想在C中实现“伪值传递”字符串对象，实现为结构，其中策略规定在传递字符串时必须放弃字符串的所有权（或者首先复制它并传递副本）作为参数。如果实现使用对象传递的引用计数存储只是对存储的引用，那么这可能会特别有效，因此“复制”操作只是引用计数增量加上普通的包装结构分配（或者甚至按值传递结构。）

Answer 7

指向char作为函数变量的指针是同一个变量的地址，除非它被替换为常量字符串。您的问题不能用简单的是/否指南来解释;这取决于背景。在下面的代码中，分别在堆和堆栈上分配的结构通过引用传递，以及字符串char *，并将数据插入到结构中。请注意mallocs在使用时的不同之处，但功能完全相同。

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

// struct with all data within
typedef struct d
{
 int number;
 char  name[50];
}data;
// struct with dynamic char *
typedef struct d2
{
 int number;
 char  *name;
}dynamic_data;

// generic function placing data into struct
void InsertData ( data * out, int a, char * b )
{
  out->number = a;
  strcpy(out->name, b);
}  

// generic function placing data into second struct
void InsertData2 ( dynamic_data * out, int a, char * b )
{
  out->number = a;
  strcpy(out->name, b);
}  


int main ( void )
{
  char * text = "some string\0";
  int n = 20;
  // allocated struct
  data stuff;

  dynamic_data stuff2;

  dynamic_data * stuff3; 
  // need to allocate pointer within struct only
  stuff2.name = (char *) malloc(50 * sizeof(char));

  // heap allocated struct
  stuff3  = (dynamic_data * ) malloc(50 * sizeof(dynamic_data));
  // heap allocated sub element char *
  stuff3->name = (char *) malloc(50 * sizeof(char));


  // this is the data
  printf ( "Pre insertion data\n" );  
  printf ( "s=[%s]\n", text );
  printf ( "n=%d\n", n );

  // this is the function insertting
  InsertData ( &stuff, n,  text );
  printf ( "Post insertion data\n" );  
  printf ( "stuff.name=[%s]\n", stuff.name );
  printf ( "stuff.number=%d\n", stuff.number ); 

  // this is the function inserting
  InsertData2 ( &stuff2, n,  text );
  printf ( "Post insertion data\n" );  
  printf ( "stuff.name=[%s]\n", stuff2.name );
  printf ( "stuff.number=%d\n", stuff2.number );    

//
// This is the segfault version - if nothing was allocated for pointers into 
// this function scope, it would crash


  // this is the function insertting under a heap allocated 
    InsertData2 ( stuff3, n,  text );
  printf ( "Post insertion data - dynamic version\n" );  
  printf ( "stuff3->name=[%s]\n", stuff3->name );
  printf ( "stuff3->number=%d\n", stuff3->number ); 

  // free in reverse order
  free(stuff3->name);
  free(stuff3);
  free(stuff2.name);
  return 0;
}

char *作为C中函数的参数

7 个答案: