Next: Syntaxe des déclarations Up: Les déclarations Previous: Qualificatifs de type

Sous-sections

Fonction à nombre variable de paramètres

Il est possible de déclarer une fonction comme ayant un nombre variable de paramètres en << déclarant >> les paramètres optionnels par l'unité lexicale ... (3 points à la suite). Une fonction peut avoir à la fois des paramètres obligatoires et des paramètres optionnels, les paramètres obligatoires apparaissant en premier et l'unité lexicale ... apparaissant en dernière position dans la liste de déclaration des paramètres formels.

Dans le corps de la fonction on ne dispose pas de nom pour désigner les paramètres. L'accès à ceux-ci ne peut se faire qu'en utilisant les macros suivantes définies dans la bibliothèque standard :

va_list: permet de déclarer une variable opaque au programmeur, à passer en paramètre aux autres macros. Cette variable s'appelle traditionnellement ap (pour argument pointer), et a pour but de repérer le paramètre effectif courant.
va_start: doit être appelée avant toute utilisation de va_arg. La macro va_start a deux paramètres : la variable ap et le nom du dernier paramètre obligatoire de la fonction.
va_arg: délivre le paramètre effectif courant : le premier appel à va_arg délivre le premier paramètre, puis chaque nouvel appel à va_arg délivre le paramètre suivant. La macro va_arg admet deux paramètres : la variable ap et le type du paramètre courant.
va_end: doit être appelée après toutes les utilisations de va_arg. La macro va_end admet un seul paramètre : la variable ap.

Rien n'est prévu pour communiquer à la fonction le nombre et le type des paramètres effectivement passés : c'est un problème à la charge du programmeur.

Exemple 1

Ci-dessous l'exemple de la fonction addn qui réalise la somme de ses paramètres optionnels.

#include <stdio.h>
#include <stdarg.h>
/*****************************************************************************/
/*                                                                           */
/*                              addn                                         */
/*                                                                           */
/*   But:                                                                    */
/*      réalise l'addition d'un nombre variable de paramètres                */
/*                                                                           */
/*****************************************************************************/
int addn(int nbopd, ...)         /*   nbopd = nombre d'opérandes du add      */
{
int i, s = 0;
va_list(ap);                     /*   déclaration de ap                      */

va_start(ap,nbopd);              /*   initialisation de ap                   */
for( i = 1; i <= nbopd; i++)
   s = s + va_arg(ap,int);       /*   va_arg() donne le paramètre courant    */
va_end(ap);                      /*   on a fini                              */
return(s);
}

/*****************************************************************************/
/*                              main                                         */
/*****************************************************************************/
int main()
{
printf("resu = %d\n",addn(3,10,11,12));   /*   imprime 33                    */
}

Dans cet exemple, le problème du nombre de paramètres effectifs a été réglé par un paramètre obligatoire de la fonction : nbopd. En ce qui concerne le type des paramètres effectifs, ils sont tous supposés être entiers, d'où le va_arg(ap,int).

Exemple 2

Dans la bibliothèque standard, il y a deux fonctions utilisées couramment qui admettent un nombre variable de paramètres : ce sont printf et scanf. Voici leur déclaration dans stdio.h :

extern int printf(const char *, ...);
extern int scanf(const char *, ...);

Ces fonctions doivent connaître le nombre et le type des paramètres optionnels. Ce problème est réglé par les séquences d'échappement se trouvant dans le paramètre obligatoire :

-: le nombre de paramètres optionnels est égal au nombre de séquences d'échappement ;
-: le type de chaque paramètre optionnel est codé dans sa séquence échappement : %c pour char, %d pour int, etc.

Next: Syntaxe des déclarations Up: Les déclarations Previous: Qualificatifs de type

Bernard Cassagne
1998-12-09