Provided by: manpages-fr-dev_4.15.0-9_all 
NOM
stdarg, va_start, va_arg, va_end, va_copy - Liste variable d'arguments
SYNOPSIS
#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);
DESCRIPTION
Une fonction peut être appelée avec un nombre variable d'arguments, eux-mêmes de types
variables. Une telle fonction est dite « variadique ». Le fichier d'en-tête <stdarg.h>
déclare un type va_list et définit trois macros permettant de parcourir la liste
d'arguments dont le nombre et les types ne sont pas connus par la fonction appelée.
La fonction appelée doit déclarer un objet de type va_list utilisé par les macros
va_start(), va_arg() et va_end().
va_start()
La macro va_start() initialise ap pour les utilisations ultérieures de va_arg() et
va_end(), et doit donc être appelée en premier.
Le paramètre dernier est le nom du dernier paramètre avant la liste variable de
paramètres, c'est-à-dire le dernier paramètre dont la fonction connaisse le type.
Comme l'adresse de ce paramètre est utilisée dans la macro va_start(), il ne doit pas être
déclaré comme une variable en registre, ni comme un type fonction ou tableau.
va_arg()
La macro va_arg() se développe en une expression qui a le type et la valeur de l'argument
suivant de l'appel. Le paramètre ap est la va_list ap initialisée par va_start(). Chaque
appel de va_arg() modifie ap pour que l'appel suivant renvoie le paramètre suivant. Le
paramètre type est le nom du type, indiqué de telle manière qu'un pointeur sur un objet de
ce type puisse être déclaré simplement en ajoutant un astérisque à type.
La première utilisation de la macro va_arg() après celle de va_start() renvoie l'argument
suivant dernier. Les invocations successives renvoient les valeurs des arguments restants.
S'il n'y a pas d'argument suivant, ou si type n'est pas compatible avec le type du
prochain argument effectif, des erreurs imprévisibles se produiront.
Si ap est passé à une fonction qui utilise va_arg(ap,type) alors la valeur de ap est
indéfinie après le retour de cette fonction.
va_end()
À chaque invocation de va_start() doit correspondre une invocation de va_end() dans la
même fonction. Après l'appel va_end(ap) la variable ap est indéfinie. Plusieurs traversées
de la liste sont possibles, à condition que chacune soit encadrée par va_start() et
va_end(). va_end() peut être une macro ou une fonction.
va_copy()
La macro va_copy() copie la liste d'arguments variables (précédemment initialisés) src
vers dest. Le comportement serait similaire si va_start() était appliqué à dest avec le
même argument dernier, suivi du même nombre d'invocations de va_arg() qui seraient
utilisées pour atteindre l'état actuel de src.
Une implémentation évidente est de représenter va_list par un pointeur dans la pile de la
fonction variadique. Dans une telle situation (de loin la plus courante), rien ne semble
s'opposer à une affectation
va_list aq = ap;
Malheureusement, il y a aussi des systèmes qui créent une table de pointeurs (de
longueur 1), et on devrait écrire
va_list aq;
*aq = *ap;
De plus, sur les systèmes où les paramètres sont passés dans des registres, il peut être
nécessaire pour va_start() d'allouer de la mémoire, d'y enregistrer les paramètres ainsi
que l'indication du paramètre suivant, afin que va_arg() puisse balayer la liste. Ainsi
va_end() pourra libérer la mémoire allouée. Pour gérer ces situations, C99 ajoute une
macro va_copy(), afin que les affectations ci-dessus soient remplacées par
va_list aq;
va_copy(aq, ap);
...
va_end(aq);
À chaque invocation de va_copy() doit correspondre une invocation de va_end() dans la même
fonction. Certains systèmes qui ne disposent pas de va_copy() ont une macro __va_copy() à
la place, puisque c'était le nom proposé auparavant.
ATTRIBUTS
Pour une explication des termes utilisés dans cette section, consulter attributes(7).
┌────────────────────────────────────────────────┬──────────────────────┬─────────────────┐
│Interface │ Attribut │ Valeur │
├────────────────────────────────────────────────┼──────────────────────┼─────────────────┤
│va_start(), va_end(), va_copy() │ Sécurité des threads │ MT-Safe │
├────────────────────────────────────────────────┼──────────────────────┼─────────────────┤
│va_arg() │ Sécurité des threads │ MT-Safe race:ap │
└────────────────────────────────────────────────┴──────────────────────┴─────────────────┘
CONFORMITÉ
Les macros va_start(), va_arg() et va_end() sont conformes à C89. C99 définit la macro
va_copy().
BOGUES
Contrairement aux macros varargs() historiques, les macros stdarg() ne permettent pas aux
programmeurs de coder une fonction sans aucun argument fixe. Ce problème se pose
principalement en convertissant directement du code utilisant varargs() en code utilisant
stdarg(), mais il se pose également pour les fonctions qui désirent passer tous leurs
arguments à une fonction utilisant un argument va_list telle que vfprintf(3).
EXEMPLES
La fonction foo() prend une chaîne de caractères de mise en forme, et affiche les
arguments associés avec chaque format correspondant au type indiqué.
#include <stdio.h>
#include <stdarg.h>
void
foo(char *fmt, ...) /* '...' est la syntaxe C des fonctions variadiques */
{
va_list ap;
int d;
char c;
char *s;
va_start(ap, fmt);
while (*fmt)
switch (*fmt++) {
case 's': /* chaîne */
s = va_arg(ap, char *);
printf("chaîne %s\n", s);
break;
case 'd': /* entier */
d = va_arg(ap, int);
printf("entier %d\n", d);
break;
case 'c': /* caractère */
/* il faut une conversion de type ici
puisque va_arg ne prend que des
types entièrement promus */
c = (char) va_arg(ap, int);
printf("caractère %c\n", c);
break;
}
va_end(ap);
}
VOIR AUSSI
vprintf(3), vscanf(3), vsyslog(3)
COLOPHON
Cette page fait partie de la publication 5.13 du projet man-pages Linux. Une description
du projet et des instructions pour signaler des anomalies et la dernière version de cette
page peuvent être trouvées à l'adresse https://www.kernel.org/doc/man-pages/.
TRADUCTION
La traduction française de cette page de manuel a été créée par Christophe Blaess
<https://www.blaess.fr/christophe/>, Stéphan Rafin <stephan.rafin@laposte.net>, Thierry
Vignaud <tvignaud@mandriva.com>, François Micaux, Alain Portal <aportal@univ-montp2.fr>,
Jean-Philippe Guérard <fevrier@tigreraye.org>, Jean-Luc Coulon (f5ibh) <jean-
luc.coulon@wanadoo.fr>, Julien Cristau <jcristau@debian.org>, Thomas Huriaux
<thomas.huriaux@gmail.com>, Nicolas François <nicolas.francois@centraliens.net>, Florentin
Duneau <fduneau@gmail.com>, Simon Paillard <simon.paillard@resel.enst-bretagne.fr>, Denis
Barbier <barbier@debian.org>, David Prévot <david@tilapin.org>, Cédric Boutillier
<cedric.boutillier@gmail.com>, Frédéric Hantrais <fhantrais@gmail.com> et Grégoire Scano
<gregoire.scano@malloc.fr>
Cette traduction est une documentation libre ; veuillez vous reporter à la GNU General
Public License version 3 ⟨https://www.gnu.org/licenses/gpl-3.0.html⟩ concernant les
conditions de copie et de distribution. Il n'y a aucune RESPONSABILITÉ LÉGALE.
Si vous découvrez un bogue dans la traduction de cette page de manuel, veuillez envoyer un
message à ⟨debian-l10n-french@lists.debian.org⟩.
22 mars 2021 STDARG(3)