Les fonction à nombre d'arguments variable

Interface

La fonction admet n'importe quel type de retour.
Elle a obligatoirement un paramètre fixe
Les paramètres variables marqués par l'ellipse '...', sont obligatoirement les derniers.

Ces prototypes sont valides :

void f(int a, ...);
int f(int a, char *b, ...);

etc.

Le rôle du dernier paramètre fixe est de fournir un moyen de déterminer le nombre et éventuellement le type des paramètres variables (donc passés après).

Exemple :

   
void f (int n, ...);

<...>
{
   f(3, 'a', 'b', 'c');
}

Ici, le dernier paramètre fixe indique le nombre de caractères passés.

Un effort particulier doit être fait au niveau de la documentation de la fonction, car il n'y a pas de contrôle possible de la part du compilateur. Si on se trompe de type ou de nombre, c'est le drame...

Implémentation

Elle varie évidemment selon la fonction à réaliser, mais elle s'appuie sur quelques principes communs :

Inclure <stdarg.h> pour accéder aux fonctions et macros de manipulation des paramètres variables.
Définir une variable de traitement des variadics de type va_list
Initialiser cette variable correctement avec va_start() et le nom du dernier paramètre fixe
Récupérer et traiter les paramètres selon la spécification de la fonction
Terminer l'analyse proprement avec va_end().

#include <stdarg.h>

void f (int n, ...)
{
   va_list va;
   va_start (va, n);

   /* traitement des paramètres selon la fonction */

   va_end (va);
}

La récupération des paramètre se fait séquentiellement de gauche à droite par appels successifs à va_arg() en précisant le type attendu, parmi 'int', 'long', 'double', 'void*' et 'char*' [C90].

int x = va_arg (va, int);
double y = va_arg (va, double);
char *z = va_arg (va, char *);

etc.

il doit y avoir correspondance parfaite entre le type de la variable et celui passé en paramètre à la macro va_arg().

Là encore, la vigilance est de rigueur, car aucun contrôle n'est possible de la part du compilateur.

Exemple d'implémentation de la fonction présentée au-dessus.


#include <stdarg.h>
#include <stdio.h>

void f (int n, ...)
{
   va_list va;
   va_start (va, n);

   int i;

   for (i = 0; i < n; i++)
   {
      int c = va_arg (va, int);
      putchar (c);
   }
   putchar ('\n');
   va_end (va);
}

int main (void)
{
   f (3, 'a', 'b', 'c');
   f (4, 'x', 'y', 'z', 't');

   return 0;
}

abc
xyzt

Process returned 0 (0x0)   execution time : 0.025 s
Press any key to continue.

haut

Conclusion

Nous avons jeté les bases de la construction des fonctions variadics. Attention, ces fonctions sont une source importante de problèmes invisibles au yeux du compilateur.

Ne pas les utiliser dans des projets critiques sans une procédure de validation de l'implémentation et de l'usage extrêmement rigoureuse. Dans certains domaines sensibles (médical, avionique, nucléaire), leur usage est tout simplement interdit.

Introduction

Interface

Implémentation

Conclusion