Provided by: manpages-es-dev_4.13-4_all 
NOMBRE
stdarg, va_start, va_arg, va_end, va_copy - lista de argumentos variable
SINOPSIS
#include <stdarg.h>
void va_start(va_list ap, last);
type va_arg(va_list ap, type);
void va_end(va_list ap);
void va_copy(va_list dest, va_list src);
DESCRIPCIÓN
Una función podría ser llamada con un número de argumentos variable de tipos igualmente variables. El
fichero de cabecera (include) <stdarg.h> declara un tipo va_list y define tres macros para moverse a
través de una lista de argumentos cuyo número y tipo no son conocidos para la función llamada.
Dicha función debe declarar un objeto de tipo va_list el cual es utilizado por las macros va_start(),
va_arg() y va_end().
va_start()
La macro va_start() inicializa ap para su uso posterior por va_arg() y va_end(), y debe ser llamada en
primer lugar.
The argument last is the name of the last argument before the variable argument list, that is, the last
argument of which the calling function knows the type.
Because the address of this argument may be used in the va_start() macro, it should not be declared as a
register variable, or as a function or an array type.
va_arg()
The va_arg() macro expands to an expression that has the type and value of the next argument in the
call. The argument ap is the va_list ap initialized by va_start(). Each call to va_arg() modifies ap
so that the next call returns the next argument. The argument type is a type name specified so that the
type of a pointer to an object that has the specified type can be obtained simply by adding a * to type.
El primer uso de la macro va_arg() despues de va_start() devuelve el argumento tras last. Invocaciones
sucesivas devolverán los valores del resto de los argumentos.
Si no hay próximo argumento, o si type no es compatible con el tipo del próximo argumento, se producirán
errores impredecibles.
Si ap es pasado a una función que usa va_arg(ap,type), el valor de ap es indefinido al regresar dicha
función.
va_end()
A cada invocación de va_start() le corresponde una invocación de va_end() en la misma función. Después de
la llamada a va_end(ap) la variable ap es indefinida. Son posibles varios recorridos de la lista, cada
uno comprendido entre va_start() y va_end(). va_end() puede ser una macro o una función.
va_copy()
The va_copy() macro copies the (previously initialized) variable argument list src to dest. The
behavior is as if va_start() were applied to dest with the same last argument, followed by the same
number of va_arg() invocations that was used to reach the current state of src.
Una implementación obvia haría que va_list fuera un puntero al marco de pila de la función. En tal caso
(con mucho el más común) no hay ningún problema con una asignación del tipo
va_list aq = ap;
Desafortunadamente, también hay sistemas que lo implementan como un array de punteros (de longitud 1), y
por tanto es necesario
va_list aq;
*aq = *ap;
Finally, on systems where arguments are passed in registers, it may be necessary for va_start() to
allocate memory, store the arguments there, and also an indication of which argument is next, so that
va_arg() can step through the list. Now va_end() can free the allocated memory again. To accommodate
this situation, C99 adds a macro va_copy(), so that the above assignment can be replaced by
va_list aq;
va_copy(aq, ap);
...
va_end(aq);
A cada invocación de va_copy() le corresponde una invocación de va_end() en la misma función. Algunos
sistemas que no proporcionan va_copy() tienen __va_copy() en su lugar, puesto que ese fue el nombre usado
en la propuesta inicial.
ATRIBUTOS
Para obtener una explicación de los términos usados en esta sección, véase attributes(7). ┌──────────────────────┬────────────────────┬───────────────────┐ │Interfaz │ Atributo │ Valor │ ├──────────────────────┼────────────────────┼───────────────────┤ │va_start(), va_end(), │ Seguridad del hilo │ Multi-hilo seguro │ │va_copy() │ │ │ ├──────────────────────┼────────────────────┼───────────────────┤ │va_arg() │ Seguridad del hilo │ MT-Safe race:ap │ └──────────────────────┴────────────────────┴───────────────────┘
CONFORME A
Las macros va_start(), va_arg() y va_end() concuerdan con C89. C99 define la macro va_copy().
ERRORES
Unlike the historical varargs macros, the stdarg macros do not permit programmers to code a function with
no fixed arguments. This problem generates work mainly when converting varargs code to stdarg code, but
it also creates difficulties for variadic functions that wish to pass all of their arguments on to a
function that takes a va_list argument, such as vfprintf(3).
EJEMPLOS
La función foo toma una cadena de caracteres de formato e imprime el argumento asociado con cada caracter
de formato basado en el tipo.
#include <stdio.h>
#include <stdarg.h>
void
foo(char *fmt, ...) /* '...' is C syntax for a variadic function */
{
va_list ap;
int d;
char c;
char *s;
va_start(ap, fmt);
while (*fmt)
switch (*fmt++) {
case 's': /* string */
s = va_arg(ap, char *);
printf("string %s\n", s);
break;
case 'd': /* int */
d = va_arg(ap, int);
printf("int %d\n", d);
break;
case 'c': /* char */
/* need a cast here since va_arg only
takes fully promoted types */
c = (char) va_arg(ap, int);
printf("char %c\n", c);
break;
}
va_end(ap);
}
VÉASE TAMBIÉN
vprintf(3), vscanf(3), vsyslog(3)
COLOFÓN
Esta página es parte de la versión 5.10 del proyecto Linux man-pages. Puede encontrar una descripción del
proyecto, información sobre cómo informar errores y la última versión de esta página en
https://www.kernel.org/doc/man-pages/.
TRADUCCIÓN
La traducción al español de esta página del manual fue creada por Juan Piernas <piernas@ditec.um.es> y Miguel Pérez Ibars <mpi79470@alu.um.es> Esta traducción es documentación libre; lea la GNU General Public License Version 3 ⟨https://www.gnu.org/licenses/gpl-3.0.html⟩ o posterior con respecto a las condiciones de copyright. No existe NINGUNA RESPONSABILIDAD. Si encuentra algún error en la traducción de esta página del manual, envíe un correo electrónico a debian-l10n-spanish@lists.debian.org ⟨⟩. 1 Noviembre 2020 STDARG(3)