关于函数返回的字符指针的最佳实践[关闭]

Question

在处理返回指向 C 字符串的 malloc 指针的函数时，最佳实践是什么？

这是一个例子：

FILE *f;
char *tmp;
for (i = 0; i <= 10; i++) {
    tmp = concat(fn, i);
    f = fopen(tmp, "w");
    free(tmp);
    // read f, do something useful ...
    fclose(f);
}

char* concat(char *a, int b) 返回一个指向新 C 字符串的指针，其中包含 a 和 b 的串联。

我不仅必须指定一个临时指针，然后将其传递给fopen，我还必须每次都传递给free(tmp)。我宁愿喜欢这样的东西：

FILE *f;
char *tmp;
for (i = 0; i <= 10; i++) {
    f = fopen(concat(fn, i), "w");
    // read f, do something useful ...
    fclose(f);
}

但这当然会导致内存泄漏。那么这里的最佳实践是什么？像concat(char *a, int b, char *result) 这样的结果应该是生成的 C 字符串的预分配内存？此解决方案有其缺点，例如 result 的大小有限或不是最佳大小。

Answer 1

更坚固的设计：

FILE *open_file_number(const char *str, int number)
{
    size_t size = strlen(str) + 32;
    char *path = malloc(size);

    if (path == NULL)
    {
        return NULL;
    }
    snprintf(path, size, "%s%d", str, number);

    FILE *file = fopen(path, "w");

    free(path);
    return file;
}

for (i = 0; i <= 10; i++)
{
    FILE *file = open_file_number(some_path, i);

    if (file != NULL)
    {
        // Do your stuff
        fclose(file);
    }
}

Answer 2

这两种方法都在行业中使用。在您的示例中，人们可以假设生成的文件名的最大大小并以这种方式使用本地数组：

for (int i = 0; i <= 10; i++) {
    char filename[1024];
    snprintf(filename, sizeof filename, "%s%d", fn. i);
    FILE *f = fopen(filename, "w");
    if (f != NULL) {
        // read f, do something useful ...
        fclose(f);
    } else {
        // report the error?
    }
}

请注意，可以使用if (snprintf(filename, sizeof filename, "%s%d", fn. i) >= (int)sizeof filename) 检测截断。

如果不应该对文件名长度进行假设，或者文件名组合方法更复杂，则返回分配的字符串可能是更合适的选择，但也应该测试内存分配错误：

for (int i = 0; i <= 10; i++) {
    char *filename = concat(fn, i);
    if (filename == NULL) { 
       /* handle the error */
       ...
       // break / continue / return -1 / exit(1) ...
    }
    FILE *f = fopen(filename, "w");
    if (f == NULL) {
        /* report this error, using `filename` for an informative message */
    } else {
        // read f, do something useful...
        // keep `filename` available for other reporting 
        fclose(f);
    }
    free(filename);
}

如果您还没有准备好执行所有这些记录，您可能应该使用具有更精细对象生命周期管理或垃圾收集器的不同语言。

---

最后，使用 C99 复合文字，您可以定义 concat 以适应您的简化用例：

char *concat(char *dest, const char *s, int b) {
    sprintf(dest, "%s%d", s, b);
    return dest;
}
#define CONCAT(a, b) concat((char[strlen(a) + 24]){""}, a, b)

CONCAT 定义了一个未命名的局部变量长度char 适当大小的数组，并在其中构造字符串a 和int b 的串联。我将大小写改为大写，以强调 a 在扩展中被计算两次，因此不应该是一个涉及副作用的表达式。

您可以在第二个代码片段中按预期使用此宏：

    FILE *f;
    char *tmp;
    for (i = 0; i <= 10; i++) {
        f = fopen(CONCAT(fn, i), "w");
        // read f, do something useful ...
        fclose(f);
    }

我可能不会推荐这种用法，但这只是我的意见。

Answer 3

在处理返回指向 C 字符串的 malloc 指针的函数时，最佳实践是什么？

最佳做法：不要使用它们。一个期望调用者free 返回数据的库几乎可以肯定设计得很糟糕，只有极少数例外。我们从 40 年的 C 语言历史中知道这一点，其中糟糕的编写库已经产生了数百万个内存泄漏错误。

合理、有用的库 API 设计的基本规则是：

分配东西的人负责收拾自己的烂摊子。

由于 C 没有 RAII 或构造函数/析构函数，不幸的是，这意味着健全的库需要为您提供清理功能，并且您需要记住调用它。如果它不提供这样的功能，您可能需要考虑编写执行此操作的包装器函数 - 为它们纠正错误的库设计。

如果您是实现该库的人，则应始终尽可能将内存分配留给调用者。传统上，这是通过函数获取指向它写入的缓冲区的指针来完成的。然后将其留给调用者分配足够的内存（如strcpy/strcat），或者提供一个具有最大缓冲区大小的变量，之后函数返回它实际使用的缓冲区的大小（如fgets )。

---

在您的示例中，精心设计的 concat 可能看起来像

const char* concat (char* restrict dst, const char* restrict src, int i);

其中src 是源字符串，i 是要添加的整数，dst 是调用者提供的足够大的缓冲区。可选地，为方便起见，该函数返回一个等效于dst 的指针。上面还实现了正确的 const 正确性 加上一个带限制的微优化，这意味着传递的指针不允许重叠。

用法：

char buf [LARGE_ENOUGH];
fp = fopen(concat(buf, foo, i), "w");

Answer 4

您的第一个代码 sn-p，在您使用完后保存返回的指针和 free 它，是使用返回 malloc 内存的函数的正确方法。

有几个 POSIX 函数，例如 strdup 和 getline，以这种方式工作，所以这是一个众所周知的习语。

替代方案是：

• 返回指向静态缓冲区的指针。这样做的缺点是它不是线程安全的，也不能在一个表达式中调用两次。
• 接受一个指向适当大小缓冲区的指针，在这种情况下，适当大小的缓冲区取决于调用者。

Answer 5

如果您知道字符串的最大大小，您还可以执行以下操作：

char* concat_(char* buf, size_t s, char *a, int b)
{
    /* ... your code ... */
    return buf;
}

#define concat(a, b)    concat_((char[100]){""}, 100, (a), (b))

宏分配一个未命名的局部变量并将其传递给concat_ 函数。然后这个函数可以做它以前做过的任何事情，只返回指向同一个对象的指针。没有malloc，没有free，不用担心（除了可能会炸毁你的堆栈，如果你让缓冲区太大）。

编辑： 请注意，正如 Gerhardh 在 cmets 中指出的那样，这会创建一个 local 对象（具有自动存储持续时间），因此宏返回的指针仅在实际调用该宏的同一块。因此，例如，您不能将该指针用作调用宏的函数的返回值。