C ++：自発的な考古学のセッションと、Cのスタイルで変数関数を使用しない理由

標準の省略記号とva_listについての説明

• 任意の数の引数を取る関数を宣言できます。 つまり 関数は、パラメーターよりも多くの引数を持つことができます。 これを行うには、パラメーターのリストが省略記号で終わる必要がありますが、少なくとも1つの固定パラメーター[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; } 

  
  はい、関数は引数の数を知りません。 彼女はどういうわけかこの番号を渡す必要があります。 この場合、単一の名前付き引数を使用します（別の一般的なオプションは、 execlや0のように、最後の引数としてNULLを渡すことです）。
• 最後の名前付き引数には、 registerストレージクラスを含めることはできません。関数または配列にすることはできません。 それ以外の場合、未定義の動作[C11 7.16.1.4/4] 。
• さらに、最後に指定された引数とすべての名前のない引数に、「 デフォルト引数のプロモーション 」が適用されます （ デフォルト引数のプロモーション 。この概念のロシア語への適切な翻訳があれば、喜んで使用します）。 つまり、引数の型がchar 、 short （符号付きまたは符号なし）、またはfloat場合、対応するパラメーターはint 、 int （符号付きまたは符号なし）、またはdoubleとしてアクセスする必要があります。 それ以外の場合、未定義の動作[C11 7.16.1.1/2] 。
• va_list型については、 <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のみが警告を発行しました。
   
   
   クラン警告

    ./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は、単一のコメントなしでこのコードをコンパイルしました。 lang6.0.0は警告を発行しましたが、それでもコンパイルしました。
   
   
   クラン警告

    ./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引数va_start参照であってはなり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 type- char 、 shortまたはfloat va_arg上げるように要求するのは間違っています。
   
   
   無効なコード

    #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は、 floatではなくdoubleを使用する必要があるという警告を出します。このコードがまだ実行されている場合、プログラムはエラーで終了します。
   
   
   GCC警告

    ./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は、未定義の動作を警告し、 floatをdouble置き換えることを提案します。
   
   
   クラン警告

    ./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がすべての引数をスタック経由で呼び出された関数に渡し、2番目では最初の4つ（Windows）または6つ（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; } 

   
   再びClangがより厳格になりました。 彼va_arg 、 va_argの2番目の引数がPODタイプでva_argないため、このコードのコンパイルを拒否し、プログラムが起動時にva_argすることを警告します。
   
   
   クラン警告

    ./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 ++では、変数関数に名前付き引数が必要ないこと、およびオーバーロードされた関数を解決するときに変数関数が最後と見なされること（少なくとも1つの引数がある場合）が非常に便利です。 また、他の関数と同様に、変数関数は宣言することしかできませんが、呼び出すことはできません。
  
  
  例

   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(...)れた引数detect(...)を呼び出すことができるものを監視する必要があります。 いくつかの行を変更し、変数関数のすべての短所を欠いた最新の代替関数を使用したいと思います。
  

バリアントテンプレートまたは現代のC ++で任意の数の引数から関数を作成する方法

• テンプレートパラメータパッケージ（テンプレートパラメータパックは） -任意のテンプレート引数の数（0を含む）を転送することが可能である代わりにそのうち、パラメータ・テンプレートです。
  
• 関数パラメーターのパッケージ（function parameter pack）-したがって、これは（0を含む）任意の数の関数引数を取る関数パラメーターです。
  
• また、パッケージの展開（pack expansion）のみが、パラメーターパッケージで実行できます。
  

 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...}; } 

  
  
• またはラムダキャプチャリストに

   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で登場し、単項およびバイナリ、右および左になります。最も完全な説明は、いつものように、標準[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以降の非自明な型のサポートは、コンパイラの裁量に任されていました。つまり コードの動作は、コンパイラとそのバージョンに依存します。
  

• すべての引数の数とタイプを知っています。
  
• 型セーフで、引数の型を変更しないでください。
  
• 値、ポインタ、参照、ユニバーサルリンクなど、あらゆる形式で引数を渡すことができます。
  
• 他のC ++関数と同様に、引数のタイプに制限はありません。
  
• ( C ), .
  

文献と情報源

• PJプラウジャー、標準Cライブラリ
  
• ブライアンW.カーニハンとデニスM.リッチー、Cプログラミング言語、第1版
  
• ブライアンW.カーニハンおよびデニスM.リッチー、Cプログラミング言語、第2版
  
• 標準C11、ドラフトN1570
  
• C ++ 98標準
  
• C ++ 03標準
  
• C ++ 11標準、ドラフトN3337
  
• 標準C ++ 14、ドラフトN4296
  
• C ++ 17標準、ドラフトN4659
  

PS