在 C89 中使用可变参数函数而不传递参数数量或最终参数？

Question

假设我有一个可变参数函数 foo(int tmp, ...)，当调用 foo 函数时我需要知道有多少个参数。我知道有两种方法可以找出有多少个参数：

1. 在调用 foo 时使用最终参数，例如 -1，因此您的函数调用将如下所示：foo(tmp, 1, 2 , 9, -1) 当你在 foo 内部并且 va_arg 调用返回 -1 时，你知道你已经读取了所有函数参数

2. < p>在 foo 中再添加一个参数，程序员将获得参数总数，因此您将像这样调用 foo： foo(tmp, 5, 1, 2, 3, 4, 5) 或 foo(tmp, 2, 7, 8)

我曾经遵循第一种方式曾经有过以下bug。使用代码：

expr_of_type(expr, boolexpr_e, newtable_e, nil_e, -1)

其中 expr_of_type 是一个可变参数函数，并且正在检查 expr（第一个参数）是否是以下类型之一（boolexpr_e 或 new_table_e 或 nil_e 具有枚举类型的所有类型）。 我一不小心写道：

expr_of_type(expr, boolexpr_e, newtable_e, nil_e -1)

我忘记了 nil_e 和 -1 之间的逗号，因为 nil_e 有一个枚举类型，nil_e - 1 是一个有效的表达式，并且因为 nil_e 不是 0，所以在尝试获取 expr_of_type 参数时给定的可变参数函数没有找到 - 1 作为最后一个参数并继续搜索创建了一个错误，这花了我一些时间才找到。

我也不认为第二种方法很好，因为当从可变参数函数中添加或删除一个参数时，您需要更改包含总参数数量的参数。

在寻找更好的方法来使用/创建可变参数函数时，我发现 可变参数宏 可以解决我在使用第一种方法时遇到的错误。但可变参数宏可用于 C99 标准。我一直在寻找一种在 C89 中使用/创建可变参数函数的更好方法。有什么想法吗？

Answer 1

一般来说，您仍然必须以某种方式传递参数计数，无论是通过哨兵值还是通过显式计数。

但是，您可以通过制作更好的哨兵来解决哨兵问题。这就是为什么扩展为负常量的预处理器宏应该用括号括起来的原因之一：

#define VARARG_SENTINEL (-1)

然后 nil_e VARARG_SENTINEL 将生成编译错误。

使用 enum 或 const int 也可以：

enum { VARARG_SENTINEL = -1 };

使用符号常量作为哨兵值也会更好，因为其他原因（更多的自记录，更容易更改基础值）之后）。

Answer 2

如果您编译 C99，则可以使用可变参数宏来提供变量参数，而不必显式传递计数：

#include <stdio.h>
#include <stdarg.h>
 
void _foo(size_t n, int xs[])
{
    for(int i=0 ; i < n ; i++ ) {
        int x = xs[i];
        printf("%d\n", x);
    }        
}
 
#define foo(arg1, ...) do {            \
   int _x[] = { arg1, __VA_ARGS__ };   \
   _foo(sizeof(_x)/sizeof(_x[0]), _x); \
} while(0)
 
int main()
{
    foo(1, 2, 3, 4);
    foo(-1, -2, -3, -4, -5, -6, -7);
    return 0;
}

输出：

1
2
3
4
-1
-2
-3
-4
-5
-6
-7

但是，这会阻止您返回值。您可以使用 gcc 扩展返回一个值：

#include <stdio.h>
#include <stdarg.h>
 
int _foo(size_t n, int xs[])
{
    int i;
    for(i=0 ; i < n ; i++ ) {
        int x = xs[i];
        printf("%d\n", x);
    }        
    return n;
}
 
#define foo(arg1, ...) ({              \
   int _x[] = { arg1, __VA_ARGS__ };   \
   _foo(sizeof(_x)/sizeof(_x[0]), _x); \
})
 
int main()
{
    int x = foo(1, 2, 3, 4);
    printf("foo returned %d\n", x);
    x = foo(-1, -2, -3, -4, -5, -6, -7);
    printf("foo returned %d\n", x);
    return 0;
}

输出：

1
2
3
4
foo returned 4
-1
-2
-3
-4
-5
-6
-7
foo returned 7

但是，当然，宏已经死了。宏万岁！

编辑：

哎呀，没有仔细阅读OP。对不起！

Answer 3

通过使用动态结构，总是有可能避免完全可变的参数。

struct vararray {
   uint_t n;
   uint_t params[0];
};

void foo(int tmp, struct varray *pVA);

甚至可以通过不同大小的结构的联合来进行复杂化。

我们曾经有一个带有特定 API 的嵌入式控制器，我们在其中使用了这种方法，即传递给事件处理程序的固定大小的 struct 的 union 。它有一些优点，因为可以使用特定类型，并且编译器可以更好地检查函数参数的类型，因为我们不应该忘记可变参数函数没有参数类型检查。