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 correnteva_dcl
Declaração de va_alist (Somente versão de UNIX)va_end
Macro reiniciar arg_ptrva_list
typedef ponteiro de lista de argumentos definidos STDIO.Hva_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
Rotina |
Cabeçalho necessário |
Cabeçalhos opcionais |
|---|---|---|
va_arg |
<stdio.h> e <stdarg.h> |
<varargs.h> * |
va_end |
<stdio.h> e <stdarg.h> |
<varargs.h> * |
va_start |
<stdio.h> e <stdarg.h> |
<varargs.h> * |
* 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