使用 stdargs (va_start) 的 C 程序的奇怪行为 (SEGFAULT)

Question

我编写了一个可变参数 C 函数，其任务是为缓冲区分配所需的内存，然后 sprintf 在该缓冲区中提供给该函数的参数。但我看到了它的奇怪行为。它只能工作一次。如果我对这个函数有两次调用，它就会出现段错误。

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

char *xsprintf(char * fmt, ...)
{
    va_list ap;
    char *part;
    char *buf;
    size_t len = strlen(fmt)+1;

    va_start(ap, fmt);
    while (part = va_arg(ap, char *))
        len += strlen(part);
    va_end(ap);

    buf = (char*) malloc(sizeof(char)*len);

    va_start(ap, fmt);
    vsprintf(buf, fmt, ap);
    va_end(ap);

    return buf;
}

int main(int argc, const char *argv[])
{
    char *b;
    b = xsprintf("my favorite fruits are: %s, %s, and %s", "coffee", "C", "oranges");
    printf("size de buf is %d\n", strlen(b)); //this works. After it, it segfaults.
    /*
    free(b);
    b = NULL;
    */
    b = xsprintf("my favorite fruits are: %s, %s, and %s", "coffee", "C", "oranges");
    printf("size de buf is %d\n", strlen(b));
    printf("%s", b);
    return 0;
}

这是该程序的输出：

size de buf is 46
[1]    4305 segmentation fault  ./xsprintftest

我做错了什么吗？我不应该在一个函数中多次使用 va_start 吗？你还有其他选择吗？多谢！ :)

Answer 1

您应该使用 vsnprintf。使用两次。一旦使用NULL目标/零大小来找出需要分配的缓冲区的长度，然后第二次填充缓冲区。这样，即使所有参数都不是字符串，您的函数也将起作用。

正如所写，如果存在任何非字符串参数（%d、%x、%f 等），它将失败。并且计算 % 字符的数量并不是获取参数数量的有效方法。您的结果可能太多（如果有编码为 %% 的文字 % 字符）或太少（如果 %*s 还需要参数） code>、%.*d 等宽度/精度说明符）。

Answer 2

将 NULL 作为最后一个参数传递给 xsprintf()：

b = xsprintf("my favorite fruits are: %s, %s, and %s",
             "coffee", "C", "oranges", (void*)0);

然后您的 while() 循环将看到 NULL 并正确终止。

正如 R.. 在下面的评论和另一个答案中提到的那样，如果存在其他格式参数， xsprintf 函数将失败。您最好使用 vsprintf，如其他答案中所述。

我在这里的目的只是演示哨兵与 va_arg 的使用。

Answer 3

首先，尝试使用 vsnprintf。这只是个好主意。

但这不是你的问题。您的问题是您调用 va_arg 的次数不能超过参数的次数。它不返回参数的数量。您必须传入一个参数来告诉它有多少个，或者提取格式字符串中特殊标记的数量以计算出必须隐式有多少个。

这就是为什么如果你传递的参数太少，printf 会阻塞你的程序。它只会不断地从堆栈中取出东西。

Answer 4

问题在于，在没有特定定义结束的情况下访问 va_arg() 列表的代码位中：

va_start(ap, fmt);
while (part = va_arg(ap, char *))
    len += strlen(part);
va_end(ap);

stdargs.h 设施没有任何内置的-in 方法来确定 va_list() 何时结束 - 您需要通过您提出的约定明确完成该操作。使用哨兵值（如 bstpierre 的答案），或者提供计数。计数可以是提供的显式参数，也可以是隐式参数（例如通过计算格式字符串中格式说明符的数量，如 printf() 系列所做的那样）。

当然，您还存在一个问题，即您的代码当前仅支持一种格式说明符 (%s)，但我认为此时这是有意的。

Answer 5

非常感谢您的回答和想法！所以我重写了我的函数，如下所示：

void fatal(const char *msg)/*{{{*/
{
  fprintf(stderr, "program: %s", msg);
  abort ();
}/*}}}*/

void *xmalloc(size_t size)/*{{{*/
{
  register void *value = malloc(size);
  if (value == 0)
    fatal ("Virtual memory exhausted");
  return value;
}/*}}}*/

void *xrealloc(void *ptr, size_t size)/*{{{*/
{
  register void *value = realloc(ptr, size);
  if (value == 0)
    fatal ("Virtual memory exhausted");
  return value;
}/*}}}*/

char *xsprintf(const char *fmt, ...)/*{{{*/
{
    /* Heavily inspired from http://perfec.to/vsprintf/pasprintf */
    va_list args;
    char *buf;
    size_t bufsize;
    char *newbuf;
    size_t nextsize;
    int outsize;
    int FIRSTSIZE = 20;

    bufsize = 0;

    for (;;) {
        if(bufsize == 0){
            buf = (char*)  xmalloc(FIRSTSIZE);
            bufsize = FIRSTSIZE;
        }
        else{
            newbuf = (char *)xrealloc(buf, nextsize);
            buf = newbuf;
            bufsize = nextsize;
        }

        va_start(args, fmt);
        outsize = vsnprintf(buf, bufsize, fmt, args);
        va_end(args);

        if (outsize == -1) {
            /* Clear indication that output was truncated, but no
             * clear indication of how big buffer needs to be, so
             * simply double existing buffer size for next time.
             */
            nextsize = bufsize * 2;

        } else if (outsize == bufsize) {
            /* Output was truncated (since at least the \0 could
             * not fit), but no indication of how big the buffer
             * needs to be, so just double existing buffer size
             * for next time.
             */
            nextsize = bufsize * 2;

        } else if (outsize > bufsize) {
            /* Output was truncated, but we were told exactly how
             * big the buffer needs to be next time. Add two chars
             * to the returned size. One for the \0, and one to
             * prevent ambiguity in the next case below.
             */
            nextsize = outsize + 2;

        } else if (outsize == bufsize - 1) {
            /* This is ambiguous. May mean that the output string
             * exactly fits, but on some systems the output string
             * may have been trucated. We can't tell.
             * Just double the buffer size for next time.
             */
            nextsize = bufsize * 2;

        } else {
            /* Output was not truncated */
            break;
        }
    }
    return buf;
}/*}}}*/

它的工作就像一个魅力！感谢一百万次:)