Funktionen mit Variablenargumentlisten (C++)

Funktionsdeklarationen mit auslassungszeichen (...) als letztes Argument verwenden eine variable Anzahl von Argumenten. C++ stellt die Typüberprüfung nur für die explizit deklarierten Argumente bereit. Sie können Variablenargumentlisten verwenden, wenn die Anzahl und die Typen von Argumenten für die Funktion variieren können. Die printf Funktionsfamilie ist ein Beispiel für Funktionen mit Variablenargumentlisten.

Funktionen mit Variablenargumenten

Verwenden Sie die Makros, die in der Standarddatei enthalten sind, wie in diesem Artikel erläutert, um auf Argumente zuzugreifen, die in der Standarddatei <stdarg.h> enthalten sind.

Microsoft-spezifisch

Mit Microsoft C++ können die Auslassungspunkte als Argument angegeben werden, wenn die Auslassungspunkte das letzte Argument sind und ein Komma vor den Auslassungszeichen steht. Daher ist die Erklärung int Func( int i, ... ); legal, aber int Func( int i ... ); nicht.

Ende Microsoft-spezifisch

Die Deklaration einer Funktion, die eine variable Anzahl von Argumenten verwendet, erfordert mindestens ein Platzhalterargument, auch wenn sie nicht verwendet wird. Wenn dieses Platzhalterargument nicht angegeben wird, gibt es keine Möglichkeit, auf die verbleibenden Argumente zuzugreifen.

Wenn Argumente vom Typ char als variable Argumente übergeben werden, werden sie in Typ intkonvertiert. Wenn Die Argumente des Typs float als variable Argumente übergeben werden, werden sie in Typ doublekonvertiert. Argumente anderer Typen unterliegen den üblichen Ganzzahl- und Gleitkomma-Erweiterungen. Weitere Informationen finden Sie unter Standardkonvertierungen.

Funktionen, für die Variablenlisten erforderlich sind, werden mithilfe von Auslassungspunkten (...) in der Argumentliste deklariert. Verwenden Sie die Typen und Makros, die in der <stdarg.h> Includedatei beschrieben werden, um auf Argumente zuzugreifen, die von einer Variablenliste übergeben werden. Weitere Informationen zu diesen Makros finden Sie unter va_arg, va_copy, va_end, va_start.

Das folgende Beispiel zeigt, wie Sie mithilfe der Makros eine Variablenargumentliste verarbeiten:

// variable_argument_lists.cpp

#include <stdio.h>
#include <stdarg.h>

//  Declaration, but not definition, of ShowVar.
void ShowVar( char *szTypes, ... );

int main() {
   ShowVar( "fcsi", 32.4f, 'a', "Test string", 4 );
}

// ShowVar takes a format string of the form
// "ifcs", where each character specifies the
// type of the argument in that position.
//
// i = int
// f = float
// c = char
// s = string (char *)
//
// Following the format specification is a variable
// list of arguments. Each argument corresponds to
// a format character in the format string to which
// the szTypes parameter points
void ShowVar( char *szTypes, ... ) {
   va_list vl;
   int i;

   // szTypes is the last argument specified; you must access
   // all others using the variable-argument macros.
   va_start( vl, szTypes );

   // Step through the list.
   for( i = 0; szTypes[i] != '\0'; ++i ) {
      
      union Printable_t {
         int     i;
         float   f;
         char    c;
         char   *s;
      } Printable;

      switch( szTypes[i] ) {   // Type to expect
         case 'i':
            Printable.i = va_arg( vl, int );
            printf_s( "%i\n", Printable.i );
            break;

         case 'f':
             Printable.f = va_arg( vl, double );
             printf_s( "%f\n", Printable.f );
             break;

         case 'c':
             Printable.c = va_arg( vl, char );
             printf_s( "%c\n", Printable.c );
             break;

         case 's':
             Printable.s = va_arg( vl, char * );
             printf_s( "%s\n", Printable.s );
             break;

         default:
             break;
      }
   }
   va_end( vl );
}

32.400002
a
Test string

Das vorherige Beispiel verdeutlicht diese wichtigen Konzepte:

1. Sie müssen eine Listenmarkierung als Variable vom Typ va_list erstellen, bevor auf beliebige Variablenargumente zugegriffen wird. Im vorherigen Beispiel wird die Markierung als vl bezeichnet.
2. Auf die einzelnen Argumente wird unter Verwendung des Makros va_arg zugegriffen. Sie müssen dem va_arg-Makro den Typ des abzurufenden Arguments mitteilen, sodass es die richtige Anzahl von Bytes aus dem Stapel übertragen kann. Wenn Sie einen falschen Typ Größe festlegen, die sich von der unterscheidet, die vom aufrufenden Programm für va_arg angegeben wurde, sind die Ergebnisse unvorhersehbar.
3. Sie sollten das erhaltene Ergebnis explizit in den gewünschten Typ umwandeln, indem Sie das va_arg-Makro verwenden.
4. Sie müssen das va_end Makro aufrufen, um die Verarbeitung variabler Argumente zu beenden.