C ++：自发性考古，为什么不应该使用C风格的变量函数

标准中说了省略号和va_list呢？

• 您可以声明一个带有任意数量参数的函数。 即 一个函数可以有比参数更多的参数。 为此，其参数列表必须以省略号结尾，但是还必须至少存在一个固定参数[C11 6.9.1 / 8] ：
  
  

   void foo(int parm1, int parm2, ...); 

• 有关与省略号相对应的参数的数量和类型的信息不会传递给函数本身。 即 在最后一个命名参数（在上面的示例中为parm2 ）之后[C11 6.7.6.3/9] 。
  
• 要访问这些参数，必须使用在<stdarg.h>标头中声明的va_list类型和4个（在C11标准之前为3）宏： va_start ， va_arg ， va_end和va_copy （从C11开始） [C11 7.16] 。
  
  
  举个例子

   int add(int count, ...) { int result = 0; va_list args; va_start(args, count); for (int i = 0; i < count; ++i) { result += va_arg(args, int); } va_end(args); return result; } 

  
  是的，该函数不知道它有多少个参数。 她需要以某种方式传递这个数字。 在这种情况下，通过单个命名参数（另一个常见的选择是将NULL作为最后一个参数传递，如execl或0）。
• 最后一个命名参数不能具有register存储类；它不能是函数或数组。 否则，未定义的行为[C11 7.16.1.4/4] 。
• 而且，对于最后一个命名的自变量和所有无名的自变量，都应用了“ 默认自变量提升 ”（ 默认自变量提升 ；如果将此概念很好地翻译成俄语，我很乐意使用它）。 这意味着，如果参数的类型为char ， short （带或不带符号）或float ，则必须以int ， int （带或不带符号）或double形式访问相应的参数。 否则，未定义行为[C11 7.16.1.1/2] 。
• 关于va_list类型，只说它是在<stdarg.h>中<stdarg.h>并且是完整的（也就是说，已知这种类型的对象的大小） [C11 7.16 / 3] 。

怎么了 但是因为！

顺便说一句，没有一种可接受的方式来编写任意数量的参数的可移植函数，因为 对于被调用函数，没有可移植的方法来查找被调用时传递给它的参数数量。 ... printf是任意数量参数的最典型的C语言函数，...是不可移植的，必须为每个系统实现。

 #ifndef _STADARG #define _STADARG #define _AUPBND 1 #define _ADNBND 1 typedef char* va_list #define va_arg(ap, T) \ (*(T*)(((ap) += _Bnd(T, _AUPBND)) - _Bnd(T, _ADNBND))) #define va_end(ap) \ (void)0 #define va_start(ap, A) \ (void)((ap) = (char*)&(A) + _Bnd(A, _AUPBND)) #define _Bnd(X, bnd) \ (sizeof(X) + (bnd) & ~(bnd)) #endif 

 typedef struct { unsigned int gp_offset; unsigned int fp_offset; void *overflow_arg_area; void *reg_save_area; } va_list[1]; 

C ++中的变量函数

• 因为 与C不同，C ++允许您获取变量的register地址，然后变量函数的最后一个命名参数可以具有此存储类。
  
• 因为 C ++中出现的链接违反了C变量函数的不成文规则-参数的大小必须匹配其声明的类型的大小-然后最后一个命名参数不能是链接。 否则，行为含糊。
  
• 因为 在C ++中，没有“ 默认情况下提高参数类型 ”的概念，然后是
  

  如果参数parmN声明为...与在应用默认参数提升后产生的类型不兼容的类型，则该行为未定义

  必须替换为

  如果参数parmN声明为...与在传递没有参数的参数时导致的类型不兼容的类型，则行为未定义

如何轻松，错误地使用变量函数

1. 用提升的类型声明最后一个命名的参数是不正确的，即 char ，有signed char ， unsigned char ， singed short ， unsigned short或float 。 根据标准的结果将是不确定的行为。
   
   
   无效的代码

    void foo(float n, ...) { va_list va; va_start(va, n); std::cout << va_arg(va, int) << std::endl; va_end(va); } 

   
   
   
   在我手头的所有编译器（gcc，clang，MSVC）中，只有clang发出警告。
   
   
   lang警告

    ./test.cpp:7:18: warning: passing an object that undergoes default argument promotion to 'va_start' has undefined behavior [-Wvarargs] va_start(va, n); ^ 

   
   并且尽管在所有情况下编译后的代码都能正常运行，但您不应指望它。
   
   
   没错

    void foo(double n, ...) { va_list va; va_start(va, n); std::cout << va_arg(va, int) << std::endl; va_end(va); } 

   
   
2. 将最后一个命名的参数声明为引用是不正确的。 任何链接。 在这种情况下，该标准还保证了未定义的行为。
   
   
   无效的代码

    void foo(int& n, ...) { va_list va; va_start(va, n); std::cout << va_arg(va, int) << std::endl; va_end(va); } 

   
   gcc 7.3.0编译了此代码，没有任何注释。 lang 6.0.0发出了警告，但仍进行了编译。
   
   
   lang警告

    ./test.cpp:7:18: warning: passing an object of reference type to 'va_start' has undefined behavior [-Wvarargs] va_start(va, n); ^ 

   
   在这两种情况下，该程序都能正常运行（幸运的是，您不能依赖它）。 但是MSVC 19.15.26730表现出色-拒绝编译代码，因为 va_start参数不能为引用。
   
   
   来自MSVC的错误

    c:\program files (x86)\microsoft visual studio\2017\community\vc\tools\msvc\14.15.26726\include\vadefs.h(151): error C2338: va_start argument must not have reference type and must not be parenthesized 

   
   
   好吧，正确的选项看起来像这样

    void foo(int* n, ...) { va_list va; va_start(va, n); std::cout << va_arg(va, int) << std::endl; va_end(va); } 

   
   
3. 请求va_arg引发char类型char ， short或float是错误的。
   
   
   无效的代码

    #include <cstdarg> #include <iostream> void foo(int n, ...) { va_list va; va_start(va, n); std::cout << va_arg(va, int) << std::endl; std::cout << va_arg(va, float) << std::endl; std::cout << va_arg(va, int) << std::endl; va_end(va); } int main() { foo(0, 1, 2.0f, 3); return 0; } 

   
   这里更有趣。 编译时的gcc发出警告，有必要使用double而不是float ，并且如果仍然执行此代码，则程序将以错误结尾。
   
   
   海湾合作委员会警告

    ./test.cpp:9:15: warning: 'float' is promoted to 'double' when passed through '...' std::cout << va_arg(va, float) << std::endl; ^~~~~~ ./test.cpp:9:15: note: (so you should pass 'double' not 'float' to 'va_arg') ./test.cpp:9:15: note: if this code is reached, the program will abort 

   
   实际上，该程序因抱怨无效指令而崩溃。
   转储分析表明该程序收到了SIGILL信号。 并且还显示了va_list的结构。 对于32位，这是
   
   

    va = 0xfffc6918 "" 

   
   即 va_list只是char* 。 对于64位：
   
   

    va = {{gp_offset = 16, fp_offset = 48, overflow_arg_area = 0x7ffef147e7e0, reg_save_area = 0x7ffef147e720}} 

   
   即 完全与SystemV ABI AMD64中描述的相同。
   
   编译时发出的clang警告未定义的行为，还建议用double代替float 。
   
   
   lang警告

    ./test.cpp:9:26: warning: second argument to 'va_arg' is of promotable type 'float'; this va_arg has undefined behavior because arguments will be promoted to 'double' [-Wvarargs] std::cout << va_arg(va, float) << std::endl; ^~~~~ 

   
   但是程序不再崩溃，32位版本产生：
   
   

    1 0 1073741824 

   
   64位：
   
   

    1 0 3 

   
   MSVC会产生完全相同的结果，即使使用/Wall也不会发出警告。
   
   这里可以假定32位和64位之间的差异是由于以下事实：在第一种情况下，ABI将所有参数通过堆栈传递给调用的函数，而在第二种情况下，前四个（Windows）或六个（Linux）参数通过处理器寄存器传递，其余的则通过堆栈[ Wiki ]。 但是不，如果您不使用4而是使用19来调用foo ，并以相同的方式输出它们，结果将是相同的：32位版本完全混乱，而64位一个float为零。 即 重点当然是在ABI中，而不是在使用寄存器传递参数时。
   
   
   好吧，当然，这样做是对的

    void foo(int n, ...) { va_list va; va_start(va, n); std::cout << va_arg(va, int) << std::endl; std::cout << va_arg(va, double) << std::endl; std::cout << va_arg(va, int) << std::endl; va_end(va); } 

   
   
4. 传递带有非平凡的构造函数或析构函数作为未命名参数的类的实例是不正确的。 当然，除非该代码的命运使您至少比“现在就编译并运行”更能激发您一点。
   
   
   无效的代码

    #include <cstdarg> #include <iostream> struct Bar { Bar() { std::cout << "Bar default ctor" << std::endl; } Bar(const Bar&) { std::cout << "Bar copy ctor" << std::endl; } ~Bar() { std::cout << "Bar dtor" << std::endl; } }; struct Cafe { Cafe() { std::cout << "Cafe default ctor" << std::endl; } Cafe(const Cafe&) { std::cout << "Cafe copy ctor" << std::endl; } ~Cafe() { std::cout << "Cafe dtor" << std::endl; } }; void foo(int n, ...) { va_list va; va_start(va, n); std::cout << "Before va_arg" << std::endl; const auto b = va_arg(va, Bar); va_end(va); } int main() { Bar b; Cafe c; foo(1, b, c); return 0; } 

   
   叮叮当当再次变得更加严格。 他只是拒绝编译此代码，因为第二个参数va_arg不是POD类型，并警告该程序将在启动时va_arg 。
   
   
   lang警告

    ./test.cpp:23:31: error: second argument to 'va_arg' is of non-POD type 'Bar' [-Wnon-pod-varargs] const auto b = va_arg(va, Bar); ^~~ ./test.cpp:31:12: error: cannot pass object of non-trivial type 'Bar' through variadic function; call will abort at runtime [-Wnon-pod-varargs] foo(1, b, c); ^ 

   
   如果仍然使用-Wno-non-pod-varargs标志进行编译，那么它将是这样。
   
   MSVC警告在这种情况下，将类型与非平凡的构造函数一起使用是不可移植的。
   
   
   来自MSVC的警告

    d:\my documents\visual studio 2017\projects\test\test\main.cpp(31): warning C4840:    "Bar"          

   
   但是代码可以编译并正确运行。 在控制台中获得以下内容：
   
   
   启动结果

    Bar default ctor Cafe default ctor Before va_arg Bar copy ctor Bar dtor Cafe dtor Bar dtor 

   
   即 仅在调用va_arg时创建一个副本，事实证明该参数是通过引用传递的。 虽然不明显，但标准允许。
   
   gcc 6.3.0编译时没有任何注释。 输出是相同的：
   
   
   启动结果

    Bar default ctor Cafe default ctor Before va_arg Bar copy ctor Bar dtor Cafe dtor Bar dtor 

   
   gcc 7.3.0也不警告任何东西，但是行为正在改变：
   
   
   启动结果

    Bar default ctor Cafe default ctor Cafe copy ctor Bar copy ctor Before va_arg Bar copy ctor Bar dtor Bar dtor Cafe dtor Cafe dtor Bar dtor 

   
   即 此版本的编译器按值传递参数，并且在调用时， va_arg会创建另一个副本。 如果从构造函数/析构函数有副作用，则在从gcc的第6版切换到第7版时寻找这种差异会很有趣。
   
   顺便说一句，如果您显式传递并请求对该类的引用：
   
   
   另一个错误的代码

    void foo(int n, ...) { va_list va; va_start(va, n); std::cout << "Before va_arg" << std::endl; const auto& b = va_arg(va, Bar&); va_end(va); } int main() { Bar b; Cafe c; foo(1, std::ref(b), c); return 0; } 

   
   那么所有编译器都会抛出错误。 按标准要求。
   
   通常，如果您确实愿意，最好通过指针传递参数。
   
   
   像这样

    void foo(int n, ...) { va_list va; va_start(va, n); std::cout << "Before va_arg" << std::endl; const auto* b = va_arg(va, Bar*); va_end(va); } int main() { Bar b; Cafe c; foo(1, &b, &c); return 0; } 

   
   

重载分辨率和变量函数

 #include <iostream> void foo(...) { std::cout << "C variadic function" << std::endl; } void foo(int) { std::cout << "Ordinary function" << std::endl; } int main() { foo(1); foo(1ul); foo(); return 0; } 

 $ ./test Ordinary function Ordinary function C variadic function 

 #include <iostream> void foo(...) { std::cout << "C variadic function" << std::endl; } void foo() { std::cout << "Ordinary function without arguments" << std::endl; } int main() { foo(1); foo(); return 0; } 

 ./test.cpp:16:9: error: call of overloaded 'foo()' is ambiguous foo(); ^ ./test.cpp:3:6: note: candidate: void foo(...) void foo(...) ^~~ ./test.cpp:8:6: note: candidate: void foo() void foo() ^~~ 

但是什么时候值得使用变量函数

• 最常见和最明显的情况是向后兼容。 在这里，我将同时包括使用第三方C库（我在JNI中的情况）和为C ++实现提供C API。
  
• SFINAE 。 在这里非常有用的是，在C ++中，变量函数不需要具有命名参数，并且在解析重载函数时，变量函数被认为是最后一个（如果存在至少一个参数）。 与其他函数一样，变量函数只能声明，而不能调用。
  
  
  例子

   template <class T> struct HasFoo { private: template <class U, class = decltype(std::declval<U>().foo())> static void detect(const U&); static int detect(...); public: static constexpr bool value = std::is_same<void, decltype(detect(std::declval<T>()))>::value; }; 

  
  尽管在C ++ 14中，您可以做一些不同的事情。
  
  
  另一个例子

   template <class T> struct HasFoo { private: template <class U, class = decltype(std::declval<U>().foo())> static constexpr bool detect(const U*) { return true; } template <class U> static constexpr bool detect(...) { return false; } public: static constexpr bool value = detect<T>(nullptr); }; 

  
  在这种情况下，已经有必要注意观察哪些参数可以调用detect(...) 。 我宁愿更改几行代码，并使用现代方法替代变量函数，但要避免所有缺点。
  

变体模板或现代C ++中如何从任意数量的参数创建函数

• 模板参数包（模板参数包） -是一个参数模板，而不是它是可以传送的任何（包括0）模板参数的数量;
  
• 一包函数参数（function parameter pack）-因此，这是一个可以接受任何数量（包括0）数量的函数参数的函数参数；
  
• 包的扩展（包扩展）是唯一可以使用参数包完成的操作。
  

 template <class ... Args> void foo(const std::string& format, Args ... args) { printf(format.c_str(), args...); } 

• 函数参数包可以扩展为另一个函数的参数列表

   template <class ... Args> void bar(const std::string& format, Args ... args) { foo<Args...>(format.c_str(), args...); } 

  
  
• 或到初始化列表

   template <class ... Args> void foo(const std::string& format, Args ... args) { const auto list = {args...}; } 

  
  
• 或到lambda捕获列表

   template <class ... Args> void foo(const std::string& format, Args ... args) { auto lambda = [&format, args...] () { printf(format.c_str(), args...); }; lambda(); } 

  
  
• 可以在卷积表达式中扩展另一个函数参数包

   template <class ... Args> int foo(Args ... args) { return (0 + ... + args); } 

  
  卷积出现在C ++ 14中，可以是一元和二进制，也可以是左右。与往常一样，最完整的描述在Standard [C ++ 17 8.1.6]中。
  
• 两种类型的参数包都可以扩展为sizeof ...运算符

   template <class ... Args> void foo(Args ... args) { const auto size1 = sizeof...(Args); const auto size2 = sizeof...(args); } 

  
  

 template <class ... Args> void foo() { using OneTuple = std::tuple<std::tuple<Args>...>; using NestTuple = std::tuple<std::tuple<Args...>>; } 

使用变量模板的printf的示例实现

 void printf(const char* s) { while (*s) { if (*s == '%' && *++s != '%') throw std::runtime_error("invalid format string: missing arguments"); std::cout << *s++; } } template <typename T, typename ... Args> void printf(const char* s, T value, Args ... args) { while (*s) { if (*s == '%' && *++s != '%') { std::cout << value; return printf(++s, args...); } std::cout << *s++; } throw std::runtime_error("extra arguments provided to printf"); } 

 template <typename ... Args> void printf(const std::string& fmt, const Args& ... args) { size_t fmtIndex = 0; size_t placeHolders = 0; auto printFmt = [&fmt, &fmtIndex, &placeHolders]() { for (; fmtIndex < fmt.size(); ++fmtIndex) { if (fmt[fmtIndex] != '%') std::cout << fmt[fmtIndex]; else if (++fmtIndex < fmt.size()) { if (fmt[fmtIndex] == '%') std::cout << '%'; else { ++fmtIndex; ++placeHolders; break; } } } }; ((printFmt(), std::cout << args), ..., (printFmt())); if (placeHolders < sizeof...(args)) throw std::runtime_error("extra arguments provided to printf"); if (placeHolders > sizeof...(args)) throw std::runtime_error("invalid format string: missing arguments"); } 

重载分辨率和可变模板功能

 #include <iostream> void foo(int) { std::cout << "Ordinary function" << std::endl; } void foo() { std::cout << "Ordinary function without arguments" << std::endl; } template <class T> void foo(T) { std::cout << "Template function" << std::endl; } template <class ... Args> void foo(Args ...) { std::cout << "Template variadic function" << std::endl; } int main() { foo(1); foo(); foo(2.0); foo(1, 2); return 0; } 

 $ ./test Ordinary function Ordinary function without arguments Template function Template variadic function 

 #include <iostream> void foo(...) { std::cout << "C variadic function" << std::endl; } template <class ... Args> void foo(Args ...) { std::cout << "Template variadic function" << std::endl; } int main() { foo(1); foo(); return 0; } 

 $ ./test Template variadic function C variadic function 

快速了解可变模板功能的速度

简要总结和结论

• 他们不知道他们的论据数目或类型。开发人员必须使用该函数的部分参数，才能传递有关其余参数的信息。
  
• 隐式提高未命名参数（和姓氏）的类型。如果您忘记了它，则会得到模糊的行为。
  
• 它们保持与纯C的向后兼容性，因此不支持通过引用传递参数。
  
• 在C ++ 11之前，不支持非POD类型的参数，并且由于C ++ 11对非平凡类型的支持由编译器自行决定。即 代码的行为取决于编译器及其版本。
  

• 了解他们所有参数的数量和类型。
  
• 输入safe，请勿更改其参数的类型。
  
• 它们支持以任何形式传递参数-按值，按指针，按引用，通过通用链接。
  
• 像任何其他C ++函数一样，对参数类型没有任何限制。
  
• ( C ), .
  

文献资料

• PJ Plauger，标准C库
  
• Brian W. Kernighan和Dennis M. Ritchie，C编程语言，第一版
  
• Brian W. Kernighan和Dennis M. Ritchie，《 C编程语言》第二版
  
• 标准C11，草案N1570
  
• C ++ 98标准
  
• C ++ 03标准
  
• C ++ 11标准，草案N3337
  
• 标准C ++ 14，草案N4296
  
• C ++ 17标准，草案N4659
  

聚苯乙烯