C ++: eine Sitzung der spontanen Archäologie und warum Sie keine variablen Funktionen im Stil von C verwenden sollten

Was ist mit den Auslassungspunkten und der va_list, die im Standard angegeben sind?

• Sie können eine Funktion deklarieren, die eine beliebige Anzahl von Argumenten akzeptiert. Das heißt, Eine Funktion kann mehr Argumente als Parameter haben. Dazu muss die Liste der Parameter mit einem Auslassungszeichen enden, es muss jedoch auch mindestens ein fester Parameter [C11 6.9.1 / 8] vorhanden sein:
  
  

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

• Informationen über die Anzahl und Art der Argumente, die der Ellipse entsprechen, werden nicht an die Funktion selbst übergeben. Das heißt, nach dem zuletzt genannten Parameter ( parm2 im obigen Beispiel) [C11 6.7.6.3/9] .
  
• Um auf diese Argumente zuzugreifen, müssen Sie den im Header <stdarg.h> deklarierten Typ va_list und 4 (3 vor dem C11-Standard) Makros verwenden: va_start , va_arg , va_end und va_copy (beginnend mit C11) [C11 7.16] .
  
  
  Zum Beispiel

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

  
  Ja, die Funktion weiß nicht, wie viele Argumente sie hat. Sie muss diese Nummer irgendwie übergeben. In diesem Fall über ein einzelnes benanntes Argument (eine weitere häufige Option besteht darin, NULL als letztes Argument zu übergeben, wie in execl oder 0).
• Das zuletzt genannte Argument darf keine register , es kann keine Funktion oder ein Array sein. Andernfalls undefiniertes Verhalten [C11 7.16.1.4/4] .
• Darüber hinaus wird auf das zuletzt genannte Argument und auf alle namenlosen Argumente die " Standardargumentwerbung " angewendet ( Standardargumentwerbung ; wenn es eine gute Übersetzung dieses Konzepts ins Russische gibt, verwende ich es gerne). Dies bedeutet, dass, wenn das Argument den Typ char , short (mit oder ohne Vorzeichen) oder float , auf die entsprechenden Parameter als int , int (mit oder ohne Vorzeichen) oder double zugegriffen werden muss. Andernfalls undefiniertes Verhalten [C11 7.16.1.1/2] .
• Über den Typ va_list wird nur gesagt, dass er in <stdarg.h> und vollständig ist ( <stdarg.h> die Größe eines Objekts dieses Typs ist bekannt) [C11 7.16 / 3] .

Warum? Aber weil!

Übrigens gibt es keine akzeptable Möglichkeit, eine tragbare Funktion mit einer beliebigen Anzahl von Argumenten zu schreiben, weil Es gibt keine tragbare Möglichkeit für die aufgerufene Funktion, herauszufinden, wie viele Argumente beim Aufruf an sie übergeben wurden. ... printf , die typischste C-Sprachfunktion einer beliebigen Anzahl von Argumenten, ... ist nicht portierbar und muss für jedes System implementiert werden.

 #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]; 

Variable Funktionen in C ++

• Weil Im Gegensatz zu C können Sie in C ++ die register von Variablen abrufen. Das zuletzt genannte Argument einer Variablenfunktion kann diese Speicherklasse haben.
  
• Weil Die in C ++ angezeigten Links verstoßen gegen die ungeschriebene Regel der C-Variablenfunktionen - die Größe des Parameters muss mit der Größe seines deklarierten Typs übereinstimmen -, dann kann das zuletzt genannte Argument kein Link sein. Ansonsten vages Verhalten.
  
• Weil In C ++ gibt es kein Konzept, „ den Typ des Arguments standardmäßig zu erhöhen “ , sondern die Phrase
  

  Wenn der Parameter parmN mit ... parmN wird, einem Typ, der nicht mit dem Typ kompatibel ist, der nach Anwendung der Standardargument-Promotions resultiert, ist das Verhalten undefiniert

  muss ersetzt werden durch

  Wenn der Parameter parmN mit ... parmN wird, einem Typ, der nicht mit dem Typ kompatibel ist, der beim Übergeben eines Arguments entsteht, für das es keinen Parameter gibt, ist das Verhalten undefiniert

Wie man variable Funktionen einfach und falsch benutzt

1. Es ist falsch, das zuletzt genannte Argument mit einem heraufgestuften Typ zu deklarieren, d. H. char , signed char , unsigned char , singed short , unsigned short oder float . Das Ergebnis gemäß dem Standard ist undefiniertes Verhalten.
   
   
   Ungültiger Code

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

   
   
   
   Von allen Compilern, die ich zur Hand hatte (gcc, clang, MSVC), gab nur clang eine Warnung aus.
   
   
   Clang Warnung

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

   
   Und obwohl sich der kompilierte Code in allen Fällen korrekt verhalten hat, sollten Sie sich nicht darauf verlassen.
   
   
   Es wird richtig sein

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

   
   
2. Es ist falsch, das zuletzt genannte Argument als Referenz zu deklarieren. Beliebiger Link. Der Standard verspricht auch in diesem Fall undefiniertes Verhalten.
   
   
   Ungültiger Code

    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 hat diesen Code ohne einen einzigen Kommentar kompiliert. lang 6.0.0 hat eine Warnung ausgegeben, diese aber dennoch kompiliert.
   
   
   Clang Warnung

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

   
   In beiden Fällen hat das Programm korrekt funktioniert (zum Glück können Sie sich nicht darauf verlassen). Aber MSVC 19.15.26730 zeichnete sich aus - es weigerte sich, den Code zu kompilieren, weil va_start Argument va_start keine Referenz sein.
   
   
   Fehler von 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 

   
   
   Nun, die richtige Option sieht zum Beispiel so aus

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

   
   
3. Es ist falsch, va_arg , den Typ char , short oder float va_arg erhöhen.
   
   
   Ungültiger Code

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

   
   Es ist hier interessanter. gcc bei der Kompilierung gibt eine Warnung aus, dass double anstelle von float muss. Wenn dieser Code weiterhin ausgeführt wird, wird das Programm mit einem Fehler beendet.
   
   
   Gcc Warnung

    ./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 

   
   In der Tat stürzt das Programm mit einer Beschwerde über eine ungültige Anweisung ab.
   Eine Dump-Analyse zeigt, dass das Programm ein SIGILL-Signal empfangen hat. Und es zeigt auch die Struktur von va_list . Für 32 Bit ist dies
   
   

    va = 0xfffc6918 "" 

   
   d.h. va_list ist nur char* . Für 64 Bit:
   
   

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

   
   d.h. genau das, was in SystemV ABI AMD64 beschrieben ist.
   
   clang at compilation warnt vor undefiniertem Verhalten und schlägt außerdem vor, float durch double ersetzen.
   
   
   Clang Warnung

    ./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; ^~~~~ 

   
   Aber das Programm stürzt nicht mehr ab, die 32-Bit-Version produziert:
   
   

    1 0 1073741824 

   
   64 Bit:
   
   

    1 0 3 

   
   MSVC liefert genau die gleichen Ergebnisse, nur ohne Vorwarnung, auch mit /Wall .
   
   Hier könnte angenommen werden, dass der Unterschied zwischen 32 und 64 Bit auf die Tatsache zurückzuführen ist, dass im ersten Fall der ABI alle Argumente über den Stapel an die aufgerufene Funktion weiterleitet und im zweiten Fall die ersten vier (Windows) oder sechs (Linux) Argumente über die Prozessorregister, der Rest durch Stapel [ Wiki ]. Aber nein, wenn Sie foo nicht mit 4 Argumenten, sondern mit 19 aufrufen und auf dieselbe Weise ausgeben, ist das Ergebnis dasselbe: Volles Durcheinander in der 32-Bit-Version und Nullen für alle float in der 64-Bit-Version. Das heißt, Der Punkt ist natürlich in ABI, aber nicht in der Verwendung von Registern, um Argumente zu übergeben.
   
   
   Natürlich ist es richtig, dies zu tun

    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. Es ist falsch, eine Instanz einer Klasse mit einem nichttrivialen Konstruktor oder Destruktor als unbenanntes Argument zu übergeben. Es sei denn natürlich, das Schicksal dieses Codes reizt Sie zumindest ein wenig mehr als "hier und jetzt kompilieren und ausführen".
   
   
   Ungültiger Code

    #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 ist der strengere von allen. Er weigert sich einfach, diesen Code zu kompilieren, da das zweite Argument, va_arg kein POD-Typ ist, und warnt, dass das Programm beim Start va_arg .
   
   
   Clang Warnung

    ./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); ^ 

   
   So wird es sein, wenn Sie immer noch mit dem -Wno-non-pod-varargs .
   
   MSVC warnt davor, dass die Verwendung von Typen mit nicht trivialen Konstruktoren in diesem Fall nicht portierbar ist.
   
   
   Warnung von MSVC

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

   
   Der Code wird jedoch kompiliert und ordnungsgemäß ausgeführt. Folgendes wird in der Konsole angezeigt:
   
   
   Ergebnis starten

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

   
   Das heißt, Eine Kopie wird nur zum Zeitpunkt des Aufrufs von va_arg , und das Argument wird, wie sich herausstellt, als Referenz übergeben. Es ist irgendwie nicht offensichtlich, aber der Standard erlaubt.
   
   gcc 6.3.0 wird ohne einen einzigen Kommentar kompiliert. Die Ausgabe ist die gleiche:
   
   
   Ergebnis starten

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

   
   gcc 7.3.0 warnt auch vor nichts, aber das Verhalten ändert sich:
   
   
   Ergebnis starten

    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 

   
   Das heißt, Diese Version des Compilers übergibt Argumente nach Wert, und beim Aufruf erstellt va_arg eine weitere Kopie. Es würde Spaß machen, diesen Unterschied beim Wechsel von der 6. zur 7. Version von gcc zu suchen, wenn die Konstruktoren / Destruktoren Nebenwirkungen haben.
   
   Übrigens, wenn Sie explizit einen Verweis auf die Klasse übergeben und anfordern:
   
   
   Ein weiterer falscher Code

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

   
   dann werfen alle Compiler einen Fehler aus. Gemäß Standard.
   
   Wenn Sie wirklich wollen, ist es im Allgemeinen besser, Argumente per Zeiger zu übergeben.
   
   
   So

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

   
   

Überlastauflösung und variable Funktionen

 #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() ^~~ 

Wann lohnt es sich trotzdem, variable Funktionen zu verwenden?

• Der häufigste und offensichtlichste Fall ist die Abwärtskompatibilität. Hier werde ich sowohl die Verwendung von C-Bibliotheken von Drittanbietern (mein Fall mit JNI) als auch die Bereitstellung der C-API für die C ++ - Implementierung einbeziehen.
  
• SFINAE . Hier ist es sehr nützlich, dass in C ++ eine Variablenfunktion keine benannten Argumente haben muss und dass beim Auflösen überladener Funktionen eine Variablenfunktion als letzte betrachtet wird (wenn mindestens ein Argument vorhanden ist). Und wie jede andere Funktion kann eine variable Funktion nur deklariert, aber nie aufgerufen werden.
  
  
  Beispiel

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

  
  Obwohl in C ++ 14 können Sie etwas anders machen.
  
  
  Ein weiteres Beispiel

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

  
  Und in diesem Fall ist es bereits notwendig zu beobachten, mit welchen Argumenten detect(...) aufgerufen werden kann. Ich würde es vorziehen, ein paar Zeilen zu ändern und eine moderne Alternative zu variablen Funktionen zu verwenden, ohne all ihre Mängel.
  

Variantenvorlagen oder das Erstellen von Funktionen aus einer beliebigen Anzahl von Argumenten in modernem C ++

• Template - Parameter - Paket ( Template - Parameter - Pack ) - ist eine Parametervorlage, statt dessen ist es möglich , jede (einschließlich 0) Anzahl der Template - Argument zu übertragen;
  
• ein Paket von Funktionsparametern ( Funktionsparameterpaket ) - dementsprechend ist dies ein Funktionsparameter, der eine beliebige (einschließlich 0) Anzahl von Funktionsargumenten akzeptiert;
  
• und die Erweiterung des Pakets ( Pack-Erweiterung ) ist das einzige, was mit dem Parameterpaket durchgeführt werden kann.
  

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

• Das Funktionsparameterpaket kann in die Argumentliste einer anderen Funktion erweitert werden

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

  
  
• oder zur Initialisierungsliste

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

  
  
• oder zur Lambda-Erfassungsliste

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

  
  
• Ein weiteres Paket von Funktionsparametern kann in einem Faltungsausdruck erweitert werden

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

  
  Faltungen erschienen in C ++ 14 und können unär und binär sein, rechts und links. Die vollständigste Beschreibung findet sich wie immer im Standard [C ++ 17 8.1.6] .
  
• Beide Arten von Parameterpaketen können in den Operator sizeof ... erweitert werden

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

Beispielimplementierung von printf mit variablen Vorlagen

 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"); } 

Überlastungsauflösung und variable Vorlagenfunktionen

 #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 

Ein kurzer Hinweis zur Geschwindigkeit variabler Vorlagenfunktionen

Kurze Zusammenfassung und Schlussfolgerung

• Sie kennen weder die Anzahl ihrer Argumente noch ihre Typen. Der Entwickler muss einen Teil der Argumente an die Funktion verwenden, um Informationen über den Rest zu übergeben.
  
• Erhöhen Sie implizit die Typen unbenannter Argumente (und die zuletzt genannten). Wenn Sie es vergessen, bekommen Sie vages Verhalten.
  
• Sie behalten die Abwärtskompatibilität mit reinem C bei und unterstützen daher nicht die Übergabe von Argumenten als Referenz.
  
• Vor C ++ 11 wurden Argumente, die nicht vom Typ POD waren, nicht unterstützt , und seit C ++ 11 lag die Unterstützung für nicht triviale Typen im Ermessen des Compilers. Das heißt, Das Verhalten des Codes hängt vom Compiler und seiner Version ab.
  

• Kennen Sie die Anzahl und Art aller ihrer Argumente.
  
• Geben Sie safe ein und ändern Sie nicht die Typen ihrer Argumente.
  
• Sie unterstützen die Übergabe von Argumenten in jeder Form - nach Wert, Zeiger, Referenz, universeller Verknüpfung.
  
• Wie bei jeder anderen C ++ - Funktion gibt es keine Einschränkungen für die Argumenttypen.
  
• ( C ), .
  

Literatur und Quellen

• PJ Plauger, Die Standard C Bibliothek
  
• Brian W. Kernighan und Dennis M. Ritchie, Programmiersprache C, 1. Auflage
  
• Brian W. Kernighan und Dennis M. Ritchie, Programmiersprache C, 2. Auflage
  
• Standard C11, Entwurf N1570
  
• C ++ 98 Standard
  
• C ++ 03 Standard
  
• C ++ 11 Standard, Entwurf N3337
  
• Standard C ++ 14, Entwurf N4296
  
• C ++ 17 Standard, Entwurf N4659
  

PS