je cherche, dans une fonction acceptant un nombre indeterminé de parametres (ellipse), à passer ces parametres à unr fonction qui accepte elle aussi une nombre indeterminé de parametres.
 
exemple avec une fonction "test", bon ca sert à rien, mais c'est pour comprendre:
 

 
evidement ca marche pas;
j'ai essayé des trucs genre :  
     
    va_list liste;
    va_start(liste, format);
    printf(liste);
 
liste étant un pointeur sur la liste de parametres, je me suis dit ... mais non.
sauriez pas comment faire ?

tu fais comme pour les paramètres du main
 
 
void test(int argc, char *argv[])
{  
...
}  
 
evidemment faut convertir tes paramètres en *char

 
et je passe quoi à printf ???
ca ? => printf(argv) ???
 
j'ai pas préciser mais le but est en quelque sorte de surcharger la fonction printf
je veux faire un truc du genre :
 

 
le but etant de faire apres dans mon source :

 
et en fonction de ma variable "sortie", ca affiche ca à l'écran et/ou dans un fichier particulier et/ou dans un autre fichier particulier et/ou dans une chaine de caractere ...

bon y'a un "%s" en trop mais vous aurez rectifié

je ne suis pas sûr d'avoir tout compris, mais voila mon avis:
 
.soit tu sais d'avance quel est le type des paramètres que tu veux passer.
auquel cas tu mets tous les paramètres en question dans un tableau, et dans ta fonction tu passes un pointeur sur le tableau et sa longeur/nombre d'éléments.
 
Alors dans ta fonction, tu peux aller lire les éléments de ton tableau, sachant que tu en connais la taille.
 
.sois tu as plusieurs type différents, mais dans l'appel de ta fonction, tous les paramètres seront de même type.
auquel cas tu passes en argument le nombre d'éméments, leur type et un pointeur void* qui pointe sur le tableau. Al'interieur de ta fonction, en fonction du type, tu fais un casting sur le void* pour avoir a nouveau le bon type.
 
.sois tu ne connais ni le nombre d'éléments ni le type de chaque element (cas le plus générique) et la il faut faire des enums et des struct. désolé, pas le temps d'écrire un ex.

je sais tres bien comment récupérer les arguments d'une fonction qui en accepte un nombre indeterminé.
 
ma question serait comment passer cette liste à une fonction identique
revenons sur cette exemple tres simple
 
j'ai une fonction Affiche qui envoi à printf tous les arguments qu'on lui a passé en une seule fois.

 
par exemple, si j'écrit :
 
    Affiche("%s %s\n","Hello","World" );
 
eh ben ca me fait :
 
    printf("%s %s\n","Hello","World" );
 
et si je fait :
    Affiche("Bonjour %s %s\n","tout","le monde !!!" );
ca me fait
    printf("Bonjour %s %s\n","tout","le monde !!!" );
 

jai pas tou lu.. mais en gros tu veu faire de la surcharge de fonction ??!!
 
Tu peux pas avoir de signature inconnue a l'avance
Donc c pas possible du point de vue concept et meme technique je crois.. du fait ke la machine pourra pas faire la difference entre telle ou telle fonction...

Tu peux pas repasser les args de cette manière car les fonctions appelées ds ta fonct° (printf, sprinf et fprintf) font appel au fonctions va_start et va_end qui modifient le ptr arg_ptr. Donc la seule solut° c'est de faire toi même un fonct° qui formate les données :
 
#include <stdarg.h>
 
int ma_fonction_de_formatage(char* out, const char *format, va_list arglist)
{
/* un while qui parcourt la chaine format et la liste d'arg et qui sort la  chaîne formaté dans out */
 ...
}
 
void mon_print(const char *format, ...)
{
   va_list arglist;
   char out[512];
 
   va_start(arglist, format);
 
   ...
   ma_fonction_de_formatage(out, format, arglist);
   /* là ds out tu a la chaine formater que tu balances où tu  
    veux */
   ...
 
   va_end(arglist);
}

[edit]--Message édité par Amadeus--[/edit]

C'est ce que je suis en train de faire.
Mais je voulais savoir si y'avais pas un moyen tout con pour éviter que je me tappe l'analyse de la chaine
 
le probleme est que je veux respecter le "standard" () de formattage de printf.
et fo que je m'épluche toutes les options ...
enfin, sprintf va m'aider un peu;
 
mais je vais quand meme étudié l'option de passer la liste des parametres.
J'aurais recours à l'assembleur s'il le faut, mais je suis sûr que c'est possible (avec VC++ j'ai déjà récupéré le code assembleur de comment il empile ses parametres + la definition des macros va_start et va_arg)
je vais pas m'enuyer ce week end
 
merci pour votre aide les gars

Salut, tu as regardé dans les fonctions "vprintf", "vsprintf" et "vfprintf" ? Jettes un oeil sur le MSDN et tu trouveras des exemples de l'utilisation de ces fonctions .