va_arg, va_end, va_start

Artikel
02/26/2013

Zugriffslisten für Variable-Argument.

type va_arg(
   va_list arg_ptr,
   type 
);
void va_end(
   va_list arg_ptr 
);
void va_start(
   va_list arg_ptr,
   prev_param 
); // (ANSI version)
void va_start(
   arg_ptr 
);  // (Pre-ANSI-standardization version)

Parameter

type
Der Typ des Arguments abgerufen werden.
arg_ptr
Zeiger auf eine Liste von Argumenten.
prev_param
Parameter, die vor der erstes optionales Argument (nur ANSI).

Rückgabewert

va_argGibt das aktuelle Argument; va_startund va_end keine Werte zurückgeben.

Hinweise

Die va_arg, va_end, und va_start Makros bieten eine portable Möglichkeit, Zugriff auf die Argumente einer Funktion, wenn die Funktion eine Variable Anzahl von Argumenten akzeptiert.Zwei Versionen der Makros sind verfügbar: die Makros in STDARG definiert.H entsprechen dem Standard ANSI-C.Die Makros in VARARGS definiert.H veraltet sind und bleiben für rückwärts Kompatibilität.Sie wurden vor der ANSI-Standardisierung entworfen.

Diese Makros wird davon ausgegangen, dass die Funktion eine feste Anzahl von erforderlichen Argumente, gefolgt von einer Variablen Anzahl optionaler Argumente enthält.Die erforderlichen Argumente als normalen Parameter der Funktion deklariert sind und über die Parameternamen zugegriffen werden können.Die optionalen Argumente über die Makros in STDARG zugegriffen werden.H oder VARARGS.H, der einen Zeiger auf dem ersten optionalen Argument in der Argumentliste festgelegt, Argumente aus der Liste abrufen und den Mauszeiger zurücksetzen, wenn die Verarbeitung abgeschlossen ist.

Die ANSI-C standard, in Makros STDARG.H, werden wie folgt verwendet:

va_startLegt arg_ptr dem ersten optionales Argument in der Liste der Argumente an die Funktion übergeben.Das Argument arg_ptr muss va_list Typ.Das Argument prev_param ist der Name der erforderliche Parameter, die unmittelbar vor das erste optionale Argument in der Argumentliste.Wenn prev_param ist mit der Register-Speicher-Klasse Verhalten für das Makro ist nicht definiert deklariert.va_startverwendet werden muss, bevor va_arg wird zum ersten Mal verwendet.
va_argRuft den Wert type aus den Speicherort vom arg_ptr und arg_ptr , zeigen Sie auf das nächste Argument in der Liste mithilfe der Größe des type zu bestimmen, wo das nächste Argument beginnt.va_argkann beliebig oft innerhalb der Funktion zum Abrufen der Argumente aus der Liste verwendet.
Nachdem alle Argumente abgerufen wurden, va_end setzt den Zeiger auf NULL.

C++-Hinweis
Die Makros in VARARGS definiert.H sind veraltet und ausschließlich für rückwärts Kompatibilität.Verwenden Sie die Makros, die in STDARGS definiert.H, es sei denn, Sie mit Code vor dem ANSI-Standard arbeiten.

Bei der Kompilierung mit /clr (Common Language Runtime-Kompilierung), Programme, die mithilfe dieser Makros können unerwartete Ergebnisse erzeugen, aufgrund der Unterschiede zwischen systemeigenen und common Language Runtime-Typsysteme.Betrachten Sie dieses Programm:

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

void testit ( int i, ...)
{
   va_list argptr;
   va_start(argptr, i);

   if ( i == 0 ) {
      int n = va_arg( argptr, int );
      printf( "%d\n", n );
   } else {
      char *s = va_arg( argptr, char* );
      printf( "%s\n", s);
   }
}

int main()
{
   testit( 0, 0xFFFFFFFF ); // 1st problem: 0xffffffff is not an int
   testit( 1, NULL );       // 2nd problem: NULL is not a char*
}

Beachten Sie, dass testit erwartet, dass der zweite Parameter entweder eine int oder ein char*.Übergebenen Argumente sind "0xFFFFFFFF" (ein unsigned int, kein int) und NULL (eigentlich ein int, kein char*).Wenn für systemeigenen Code kompiliert wird, wird das Programm die Ausgabe erzeugt.

-1
(null)

Allerdings bei der Kompilierung mit /clr:pure, nicht übereinstimmende Typen dazu führen, dass das Programm eine Ausnahme generiert.Die Lösung ist, verwenden Sie explizite Umwandlungen:

int main()
{
   testit( 0, (int)0xFFFFFFFF ); // cast unsigned to int
   testit( 1, (char*)NULL );     // cast int to char*
}

Anforderungen

Header: <stdio.h> und <stdarg.h>

Altes Header: <varargs.h>

Bibliotheken

Alle Versionen von der C - Laufzeitbibliotheken.

Beispiel

// crt_va.c
/* The program below illustrates passing a variable
 * number of arguments using the following macros:
 *      va_start            va_arg              va_end
 *      va_list
 */

#include <stdio.h>
#include <stdarg.h>
int average( int first, ... );

int main( void )
{
   /* Call with 3 integers (-1 is used as terminator). */
   printf( "Average is: %d\n", average( 2, 3, 4, -1 ) );

   /* Call with 4 integers. */
   printf( "Average is: %d\n", average( 5, 7, 9, 11, -1 ) );

   /* Call with just -1 terminator. */
   printf( "Average is: %d\n", average( -1 ) );
}

/* Returns the average of a variable list of integers. */
int average( int first, ... )
{
   int count = 0, sum = 0, i = first;
   va_list marker;

   va_start( marker, first );     /* Initialize variable arguments. */
   while( i != -1 )
   {
      sum += i;
      count++;
      i = va_arg( marker, int);
   }
   va_end( marker );              /* Reset variable arguments.      */
   return( sum ? (sum / count) : 0 );
}

Output

Average is: 3
Average is: 8
Average is: 0

.NET Framework-Entsprechung

System::ParamArrayAttribute-Klasse

Siehe auch

Referenz

Argument-Zugriff

vfprintf, _vfprintf_l, vfwprintf, _vfwprintf_l

Freigeben über