c - 在 C 中返回可变长度字符串的最佳实践

Question

我有一个字符串函数，它接受指向源字符串的指针并返回指向目标字符串的指针。此功能目前有效，但我担心我没有遵循重新分级 malloc、realloc 和 free 的最佳实践。

我的函数的不同之处在于目标字符串的长度与源字符串的长度不同，因此必须在我的函数内部调用 realloc()。我通过查看文档知道...

http://www.cplusplus.com/reference/cstdlib/realloc/

内存地址可能会在 realloc 之后改变。这意味着我不能像 C 程序员那样为其他函数“通过引用传递”，我必须返回新指针。

所以我的函数原型(prototype)是:

//decode a uri encoded string
char *net_uri_to_text(char *);

我不喜欢我这样做的方式，因为我必须在运行函数后释放指针:

char * chr_output = net_uri_to_text("testing123%5a%5b%5cabc");
printf("%s\n", chr_output); //testing123Z[\abc
free(chr_output);

这意味着 malloc() 和 realloc() 在我的函数内部调用，而 free() 在我的函数外部调用。

我有高级语言(perl、plpgsql、bash)的背景，所以我的直觉是对这些东西进行适当的封装，但这可能不是 C 中的最佳实践。

问题:我的方法是最佳实践，还是应该遵循更好的方法？

完整示例

在未使用的 argc 和 argv 参数上编译和运行有两个警告，您可以安全地忽略这两个警告。

例子.c:

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

char *net_uri_to_text(char *);

int main(int argc, char ** argv) {
  char * chr_input = "testing123%5a%5b%5cabc";
  char * chr_output = net_uri_to_text(chr_input);
  printf("%s\n", chr_output);
  free(chr_output);
  return 0;
}

//decodes uri-encoded string
//send pointer to source string
//return pointer to destination string
//WARNING!! YOU MUST USE free(chr_result) AFTER YOU'RE DONE WITH IT OR YOU WILL GET A MEMORY LEAK!
char *net_uri_to_text(char * chr_input) {
  //define variables
  int int_length = strlen(chr_input);
  int int_new_length = int_length;
  char * chr_output = malloc(int_length);
  char * chr_output_working = chr_output;
  char * chr_input_working = chr_input;
  int int_output_working = 0;
  unsigned int uint_hex_working;
  //while not a null byte
  while(*chr_input_working != '\0') {
    //if %
    if (*chr_input_working == *"%") {
      //then put correct char in
      sscanf(chr_input_working + 1, "%02x", &uint_hex_working);
      *chr_output_working = (char)uint_hex_working;
      //printf("special char:%c, %c, %d<\n", *chr_output_working, (char)uint_hex_working, uint_hex_working);
      //realloc
      chr_input_working++;
      chr_input_working++;
      int_new_length -= 2;
      chr_output = realloc(chr_output, int_new_length);
      //output working must be the new pointer plys how many chars we've done
      chr_output_working = chr_output + int_output_working;
    } else {
      //put char in
      *chr_output_working = *chr_input_working;
    }
    //increment pointers and number of chars in output working
    chr_input_working++;
    chr_output_working++;
    int_output_working++;
  }
  //last null byte
  *chr_output_working = '\0';
  return chr_output;
}

Answer 1

从 C 中的函数返回 malloc 缓冲区是完全可以的，只要您记录了它们这样做的事实。许多库都这样做，即使标准库中没有函数这样做。

如果您可以廉价地计算(不太悲观的上限)需要写入缓冲区的字符数，您可以提供执行该操作的函数并让用户调用它。

接受要填充的缓冲区也是可能的，但不太方便；我见过很多这样的库:

/*
 * Decodes uri-encoded string encoded into buf of length len (including NUL).
 * Returns the number of characters written. If that number is less than len,
 * nothing is written and you should try again with a larger buffer.
 */
size_t net_uri_to_text(char const *encoded, char *buf, size_t len)
{
    size_t space_needed = 0;

    while (decoding_needs_to_be_done()) {
        // decode characters, but only write them to buf
        // if it wouldn't overflow;
        // increment space_needed regardless
    }
    return space_needed;
}

现在调用者负责分配，并且会做类似的事情

size_t len = SOME_VALUE_THAT_IS_USUALLY_LONG_ENOUGH;
char *result = xmalloc(len);

len = net_uri_to_text(input, result, len);
if (len > SOME_VALUE_THAT_IS_USUALLY_LONG_ENOUGH) {
    // try again
    result = xrealloc(input, result, len);
}

(这里，xmalloc 和 xrealloc 是我编写的“安全”分配函数，用于跳过 NULL 检查。)