va_arg va_end, va_start

Listas de argumentos de variável de acesso.

type va_arg(
      va_list arg_ptr,
      type 
);
void va_end(
   va_list arg_ptr 
);
void va_start(
   va_list arg_ptr 
);  // (UNIX version)
void va_start(
   va_list arg_ptr,
      prev_param 
); // (ANSI version)

Parâmetros

• type
  Tipo de argumento a ser recuperado.

• arg_ptr
  Ponteiro para a lista de argumentos.

• prev_param
  Parâmetro antes do primeiro argumento opcional (ANSI).

Valor de retorno

va_arg Retorna o argumento corrente; va_start e va_end não retornam valores.

Comentários

The va_arg, va_end, e va_start as macros oferecem uma forma portátil para acessar argumentos para uma função quando a função pega um número variável de argumentos. Estão disponível duas versões das macros: Macros definidas no STDARG.H estão de acordo com o padrão ANSI C e as macros definidas no VARARGS.H são compatível com a definição da UNIX sistema V.As macros são:

• va_alist
  Nome de parâmetro para a função chamada (somente versão de UNIX)

• va_arg
  Macro recuperar argumento corrente

• va_dcl
  Declaração de va_alist (Somente versão de UNIX)

• va_end
  Macro reiniciar arg_ptr

• va_list
  typedef ponteiro de lista de argumentos definidos STDIO.H

• va_start
  Macro para conjunto arg_ptr para o início da lista de argumentos opcionais (somente versão de UNIX)

Ambas as versões das macros assumem a função pega um número fixo de argumentos necessários, seguido por um número variável de argumentos opcionais.Argumentos necessários são declarados sistema autônomo parâmetros comuns para a função e podem ser acessados por meio de nomes de parâmetro.Os argumentos opcionais são acessados por meio de macros no STDARG.H ou VARARGS.H, que definido um ponteiro para o primeiro argumento opcional na lista de argumentos, recuperar argumentos da lista e reiniciar o ponteiro quando o argumento processamento está concluído.

sistema autônomo macros padrão ANSI C, definidas no STDARG.H, são usadas da seguinte maneira:

• Todas sistema autônomo necessárias argumentos para a função são declarados sistema autônomo parâmetros da maneira usual.va_dcl não é usado com as macros STDARG.H.

• va_start Define arg_ptr para o primeiro argumento opcional na lista de argumentos passados para a função. O argumento arg_ptr deve ter va_list Digite. O argumento prev_param é o nome do parâmetro necessário imediatamente anterior o primeiro argumento opcional na lista de argumentos. If prev_param é declarada com a classe de armazenamento do registro, comportamento da macro é indefinido. va_start deve ser usado antes va_arg é usado pela primeira vez.

• va_arg recupera um valor de type da localização fornecida pelo arg_ptr e os incrementos arg_ptr para apontar para o argumento seguinte na lista, usando o dimensionar de type para determinar onde começa o próximo argumento. va_arg pode ser usada várias vezes dentro da função para recuperar argumentos da lista.

• Depois de recuperar todos os argumentos, va_end Redefine o ponteiro para NULO.

As macros UNIX sistema V, definidas no VARARGS.H, operam um pouco diferente:

• sistema autônomo argumentos necessários para a função podem ser declarados sistema autônomo parâmetros da maneira usual.

• O parâmetro último (ou único) para a função representa a lista de argumentos opcionais.Este parâmetro deve ser nomeado va_alist (não confundir com va_list, que é definido sistema autônomo o tipo de va_alist).

• va_dcl é exibida após a definição da função e antes da chave de abertura esquerda da função. Essa macro é definida sistema autônomo uma declaração completa do va_alist parâmetro, incluindo o ponto-e-vírgula de terminação; portanto, não há ponto-e-vírgula deve seguir va_dcl.

• Dentro da função, va_start Define arg_ptr para o início da lista de argumentos opcionais passados para a função. va_start deve ser usado antes va_arg é usado pela primeira vez. O argumento arg_ptr deve ter va_list Digite.

• va_arg recupera um valor de type da localização fornecida pelo arg_ptr e os incrementos arg_ptr para apontar para o argumento seguinte na lista, usando o dimensionar de type para determinar onde começa o próximo argumento. va_arg pode ser usada várias vezes dentro da função para recuperar os argumentos da lista.

• Depois de recuperar todos os argumentos, va_end Redefine o ponteiro para NULO.

Quando compilado com o CLR (ComComummon Idioma Tempo de execução ComComumpilation), programas que usam essas macros podem gerar resultados inesperados causa das diferenças entre sistemas de tipos do linguagem nativo e comum em tempo de execução. Considere este programa:

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

Observe que testit seu segundo parâmetro para ser uma espera um int ou um char*. Os argumentos passados são 0xffffffff (um unsigned int, não um int) e NULL (na verdade, um int, não um char*). Quando compilado para código nativo, o programa produz a saída

-1
(null)

No entanto, quando compilado com /clr:pure, incompatibilidades de tipos com que o programa gerar uma exceção. A solução é usar conversões explícitas:

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

Requisitos

* Necessário para compatibilidade UNIX V.

Para obter informações adicionais compatibilidade, consulte Compatibilidade na introdução.

Bibliotecas

Todas as versões do C em time de execução bibliotecas.

Exemplo

// 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             va_dcl (UNIX only)
 */

#include <stdio.h>
#define ANSI            /* Comment out for UNIX version     */
#ifdef ANSI             /* ANSI compatible version          */
#include <stdarg.h>
int average( int first, ... );
#else                   /* UNIX compatible version          */
#include <varargs.h>
int average( va_list );
#endif

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. */
#ifdef ANSI             /* ANSI compatible version    */
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 );
}
#else       /* UNIX compatible version must use old-style definition.  */
int average( va_alist )
va_dcl
{
   int i, count, sum;
   va_list marker;

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

Saída

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

Equivalente do NET Framework

Classe sistema::ParamArrayAttribute

Consulte também

Referência

Argumento acesso

vfprintf, _vfprintf_l, vfwprintf, _vfwprintf_l