20

很多时候，我希望一个函数接收可变数量的参数，以 NULL 终止，例如

#define push(stack_t stack, ...) _push(__VARARG__, NULL);
func _push(stack_t stack, char *s, ...) {
    va_list args;
    va_start(args, s);
    while (s = va_arg(args, char*)) push_single(stack, s);
}

char*如果 foo 收到非变量，我可以指示 gcc 或 clang 发出警告吗？类似于 的东西__attribute__(format)，但用于相同指针类型的多个参数。

4

3 回答 3

15

我知道你正在考虑以__attribute__((sentinel))某种方式使用，但这是一个红鲱鱼。

你想要的是做这样的事情：

#define push(s, args...) ({                   \
  char *_args[] = {args};                     \
  _push(s,_args,sizeof(_args)/sizeof(char*)); \
})

包装：

void _push(stack_t s, char *args[], int argn);

您可以完全按照您希望的方式编写它！

然后你可以调用：

push(stack, "foo", "bar", "baz");
push(stack, "quux");
于 2012-05-13T11:11:49.500 回答
1

我只能想到这样的事情：

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

typedef struct tArg
{
  const char* Str;
  struct tArg* Next;
} tArg;

tArg* Arg(const char* str, tArg* nextArg)
{
  tArg* p = malloc(sizeof(tArg));
  if (p != NULL)
  {
    p->Str = str;
    p->Next = nextArg;
  }
  else
  {
    while (nextArg != NULL)
    {
      p = nextArg->Next;
      free(nextArg);
      nextArg = p;
    }
  }
  return p;
}

void PrintR(tArg* arg)
{
  while (arg != NULL)
  {
    tArg* p;
    printf("%s", arg->Str);
    p = arg->Next;
    free(arg);
    arg = p;
  }
}

void (*(*(*(*(*(*(*Print8
  (const char* Str))
  (const char*))
  (const char*))
  (const char*))
  (const char*))
  (const char*))
  (const char*))
  (const char*)
{
  printf("%s", Str);
  // There's probably a UB here:
  return (void(*(*(*(*(*(*(*)
    (const char*))
    (const char*))
    (const char*))
    (const char*))
    (const char*))
    (const char*))
    (const char*))&Print8;
}

int main(void)
{
  PrintR(Arg("HELLO", Arg(" ", Arg("WORLD", Arg("!", Arg("\n", NULL))))));
//  PrintR(Arg(1, NULL));        // warning/error
//  PrintR(Arg(&main, NULL));    // warning/error
//  PrintR(Arg(0, NULL));        // no warning/error
//  PrintR(Arg((void*)1, NULL)); // no warning/error

  Print8("hello")(" ")("world")("!")("\n");
// Same warning/error compilation behavior as with PrintR()
  return 0;
}
于 2012-05-13T09:14:21.547 回答
-1

C 可变参数的问题在于，它们实际上是在事后才用螺栓固定的，而不是真正设计到语言中的。主要问题是可变参数是匿名的，它们没有句柄，没有标识符。这导致笨拙的 VA 宏生成对没有名称的参数的引用。它还导致需要告诉那些宏变量列表从哪里开始以及参数应该是什么类型。

所有这些信息确实应该在语言本身中以适当的语法编码。

例如，可以在省略号后使用形式参数扩展现有的 C 语法，如下所示

void foo ( ... int counter, float arglist );

按照惯例，第一个参数可以用于参数计数，第二个参数用于参数列表。在函数体中，列表可以在语法上被视为一个数组。

有了这样的约定，可变参数将不再是匿名的。在函数体内，可以像引用任何其他参数一样引用计数器，并且可以像引用数组参数的数组元素一样引用列表元素，就像这样

void foo ( ... int counter, float arglist ) {
  unsigned i;
  for (i=0; i<counter; i++) {
    printf("list[%i] = %f\n", i, arglist[i]);
  }
}

借助语言本身内置的这种功能，每个对的引用都arglist[i]将被转换为堆栈帧上的相应地址。无需通过宏执行此操作。

此外，编译器会自动插入参数计数，从而进一步减少出错的机会。

打电话给

foo(1.23, 4.56, 7.89);

将被编译，就好像它已被编写

foo(3, 1.23, 4.56, 7.89);

在函数体内，任何超出实际传递的参数数量的元素访问都可以在运行时检查并导致编译时错误，从而大大提高安全性。

最后但同样重要的是，所有可变参数都是类型化的，并且可以在编译时进行类型检查，就像检查非可变参数一样。

在某些用例中，当然需要交替类型，例如在编写函数以将键和值存储在集合中时。这也可以简单地通过在省略号之后允许更多形式参数来适应，就像这样

void store ( collection dict, ... int counter, key_t key, val_t value );

然后可以将此函数称为

store(dict, key1, val1, key2, val2, key3, val3);

但会被编译为好像它已被编写

store(dict, 3, key1, val1, key2, val2, key3, val3);

实际参数的类型将在编译时对照相应的可变参数形式参数进行检查。

在函数体内，计数器将再次被其标识符引用，键和值将被引用，就好像它们是数组一样，

key[i]指第 i 个键/值对的键 value[i]指第 i 个值对的值

这些引用将被编译到它们各自在堆栈帧上的地址。

这些都不是真的很难做到，也从来没有。然而，C 的设计理念根本不利于这些特性。

如果没有一个冒险的 C 编译器实现者（或 C 预处理器实现者）带头实现这个或类似的方案，我们不太可能在 C 中看到任何这种类型的东西。

问题是那些对类型安全感兴趣并愿意投入工作来构建自己的编译器的人通常会得出这样的结论，即 C 语言已经无法挽救，人们不妨从设计更好的语言开始.

我自己也去过那里，最终决定放弃尝试，然后实现 Wirth 的一种语言，并在其中添加了类型安全的可变参数。从那以后，我遇到了其他人，他们告诉我他们自己失败的尝试。C 中正确的类型安全可变参数似乎仍然难以捉摸。

于 2016-02-02T15:13:29.977 回答