Bonjour à tous,
je souhaiterais appeler une fonction avec un nombre de paramètres variable (ex: printf...) sachant que ces paramètres sont stockés dans un tableau.
Un exemple avec un appel à la fonction printf :

Les contraintes :
- le nombre d'arguments peut varier
- je ne peux pas modifier le code de la fonction (code propriétaire)
 
En faisant une analogie à Unix, il existe la commande xargs qui génère une nouvelle commande à partir des arguments qui proviendront de l'entrée standard.
 
Merci de votre aide

va_arg / va_start / va_end / va_list / ...

C'est dans stdarg.h

edit : en fait j'suis pas sûr d'avoir bien compris ton besoin, c'est une fonction que tu dois écrire, ou une fonction que tu dois appeler ? Et dans le second cas, c'est quoi le prototype de la fonction ?

c'est une fonction que je dois appeler.
J'ai mis en exemple une initialisation d'un tableau avec les paramètres pour un appel à la fonction printf.
Il me manque un moyen pour appeler ma fonction et lui passer mon tableau comme étant une liste de paramètres.
 
Merci de ton aide.

Euh, je vois pas bien où se situe le problème.
 
Peux-tu nous donner le prototype de la fonction à appeler ?

si tu veux par contre je ne sais pas si ça va t'avancer :
 

Explication :
c'est une fonction loadrunner qui simule la soumission d'un formulaire (HTTP). Elle peut prendre plusieurs paramètres tel que la méthode employée (GET/POST), le nom des variables et leurs valeurs...
 
Or  je dois faire varier le nombre de variable dans le formulaire.
En d'autres termes, je souhaiterais savoir si une telle fonction existe :

liste_parametres étant un tableau contenant la liste des arguments.

Je ne connais aucun moyen propre de faire ça.
De ce que je peux voir ici, c'est typiquement le mauvais usage d'une va_list. En plus je connais pas le contenu de "mpszStepName", mais vu le nom, je vois même pas comment la fonction connait le nombre de paramètres qu'elle a dans sa va_list.

Bon, ce n'est pas le sujet du topic mais il faut quand-même que je rectifie cette énormité !!!
 
xargs ne génère pas de commande, il découpe l'entrée standard en morceaux sufisemment petits pour que la commande qu'on veut appeler (et accessoirement qu'on lui passe aussi comme argument) puisse les traiter
ex:

• grep -l machin `ls`  => si le "ls" renvoie trop de trucs, il est probable que "grep" râle en disant "grep: too many arguments"
• ls |xargs grep -l machin   => le "xargs" ingurgite l'info qui lui arrive du "ls" et la redécoupe en morceaux acceptables pour que le "grep" puisse les traiter => il ne génère aucune commande, il appelle lui-même "grep" qui est son argument principal

Par ailleurs, pour répondre à ton analogie, Unix (ou plus précisément un script shell) est capable de gérer un nombre d'arguments indéfinis (inconnus) car il a été programmé pour ça. En revanche, la norme C impose pour une fonction une signature (c.a.d. de connaître le nombre et le type de ses arguments). C'est pour cela que les bidules "va_arg/va_list/etc" sont généralement considérés comme "pas portables" => d'où ton problème maintenant de devoir utiliser une fonction dont on ne connait pas sa signature et qui ne contient probablement aucune doc...
 

Il m'est arrivé de devoir programmer des modules cgi-bin pour traiter des formulaires HTML. En général, les modules ne recoivent du formulaire qu'une seule variable (une grosse chaîne) qui contient toutes les valeurs du formulaire séparées par des "&"
Ex: Si le formulaire contient un INPUT name="nom" et un INPUT name="prenom", alors le cgi appelé depuis le formulaire ne recevra qu'un seul argument (stocké dans "$1" en shell ou dans "argv[1]" en C) qui contiendra "nom=<le nom entré par le gus derrière le formulaire>&prenom=<le prenom entré>"
Ensuite, avec un bon outil de split sur le "&" (IFS+set en shell ou strtok_r() en C) on peut arriver à redécouper l'info en éléments distincts...

Les va_... sont portables, c'est même standard (C89 pour la plupart de ces fonctions, C99 pour va_copy, un truc comme ça).

Par contre, là où tu as raison, c'est qu'il s'agit de macros : c'est interprété à la compilation, et on ne peut donc pas faire du dynamique (c'est pas fait pour non plus, l'exemple de printf() est parfait à cet égard).

Bref, pour moi ce prototype de fonction est... zarb. Au mieux.
L'aurait mieux fallu prendre un char** en paramètre.

En attendant une solution à ce problème, j'essaye actuellement de le contourner en passant par une fonction pouvant envoyer directement des données brutes.

Avec LoadRunner j'ai accès à la requête que le client a émise pendant l'enregistrement.
Seul soucis, je dois remplacer certains caractères par un codage spécifique : ( "|" -> %7C "+"-> %2B )

 
Réponse : tu ferais autant de printf() que d'éléments de ton tableau. Ce qui ne serait pas dérangeant.

dans mon exemple, ce n'est pas faisable, tu obtiendrais :

au lieu de :

Non, dans ton exemple ce serait tout à fait faisable, et tu ferais :

for(unsigned i = 0; param[i] != NULL; ++i)
{
   printf("param%d:%s ", i+1, param[i]);
}
printf("\n" );

(en admettant que ton tableau soit terminé par null)

for(unsigned i = 0; param[i] != NULL; ++i)
{
   printf("param%d:%s ", i+1, param[i]);
}
printf("\n" );

ah d'accord, je ne l'avais pas vu de cette façon