Bonjour,

je voudrais déclarer un pointeur de fonction vers une autre. Pourquoi ai-je un warning lorsque je fais :

dumoins est-ce valide ? N'est il pas possible de déclarer un pointeurs vers une fonction avec nombre variable d'argument vers une fonctions avec un nombre prédéfini d'arguments ?

merci par avance  

non. et tu cherches à faire quoi d'ailleurs ?

c'est possible parceque je l'ai fais en son temps, mais ca fait un bail que je n'ai plus codé en c.
 
ceci dit j'essaierai plutot
 

je cherche à faire ca. Un pointeur de fonction qui pointe vers n'importe quel type de fonction, ou plus précisemment des fonctions dont le nombres d'argument n'est pas le même et qui ont pour premier argument un int. Ca marche si je fais :

est-ce envisageable ?

et après tu utilises comment ...

par exemple (exemple bidon mais bon) :

bah t'imagines ...
 
t'as un problème de design, pas de code

pointer vers des fonctions dont le nombre des arguments n'est pas le même la je ne pense pas que ce soit possible, on peut s'inspirer de la programmation objet et surcharger une fonction, mais la définition de ta fonction doit être la même. donc tu devras avoir le même nombre d'arguments, ou alors tu fais passer tes arguments via un tableau de pointeur et tu ne passe que le tableau en paramètre.

ok ok ...Merci mais en théorie c'est possible ? je veux dire, mon truc marche non ? Imaginons que les fonctions sont déja la et que je peux pas y toucher, comment faire ??

tel quel je ne pense pas, parceque si tu regardes la définition de f dans ta fonction bidon tu verras que tu as défini le nombre d'argument, donc déja la tu ne passeras pas la compilation je pense.

 
ben ca à l'air de marcher chez moi, par contre c'est vrai qu'il faut que je passe la liste des arguments dans la fonction ma_fonction_bidon

 
Tu peux essayer avec les va_arg qui vont directement pointer là où se trouvent les arguments mais
1) ce n'est pas portable
2) ce n'est pas évident
3) ce n'est pas portable (tiens, je l'ai déjà dit)
4) c'est moche
 
Pour les fonctions, il y a un grand principe à connaître qui est la notion de "signature" (ce qui identifie une fonction). Et une fonction est identifiée par son nom, le nombre de ses arguments et leur type.
 
Sinon j'aime bien ta façon de chercher plein de trucs. Mais comme pour tout langage, il y a des limites. Par exemple ne vient pas nous demander si tu peux créer une fonction nommée "extern()" ou bien comment faire pour appeler la fonction "main()" depuis une fonction infèrieure...

salut
oui je suis d'accord c'est très très moche ... je voulais savoir si en théorie je peux le faire, même si je le ferai pas car c'est mal (c'est mal ). Y'aurait-il une solution néanmoins si on souhaite exploiter des fonctions "à la volée", que celles ci soient déja disponible (donc pas possible de changer de protoype, etc), et qu'elles n'aient pas le meme nombre d'arguments ?

ps: comment fais-ton pour créer une fonction extern qui appelle la fonction main ?  

Oui tu peux le faire, et d'ailleurs tu n'es même pas obligé de mettre des "...". Le fait de mettre des "..." ne rend pas la chose plus propre.

 
salut
comment faire alors ? Je mettais des "..." car le nombre de paramètres varie d'une fonction à l'autre...

Tu ne met rien : void (*f)()

c'est possible ça ?? Mais comment se fesse ?????? Comment se fesse faice que l'on puisse déclarer un pointeur de fonctions sans paramètres et lui passer une adresse qui pointe vers une fonction de 1 ou plus paramètres??!!? C'est une hérésie, non ? Pourtant ceci marche :

oO, mais pourquoi donc comment qu'est-ce ainsi d'ou quoi ? Dans ce cas quel intéret de déclarer un void (*f) (void *a, void *b); dans certains cas, plutot qu'un void (*f)() ??  

(*f)() veut dire qu'on ne dit rien sur les arguments de f, pas que f ne prend pas d'arguments (qui s'écrirait (*f)(void)).

 
ok ... alors dans ce cas à quoi sert la notation "..." ??

pense à fprintf

 
mais dans ce cas pourquoi le prototype n'est pas int fprintf(); ?

Non mais les "()" ça ne marche que pour les déclarations. Quand tu définies ta fonction il faut évidemment donner tous les arguments. D'où l'utilité des "..." par définir des fonctions à arguments variables.

je ne suis pas sûr de comprendre ... mon exemple ci dessus marche mais je n'ai pas utilisé la notation ..., ou faudrais-je que je l'utilise ? comment faire pour passer la liste d'arguments ? Avec un void * ? Et si les arguements ne sont pas tous de meme type

au fait merci pour votre aide    

Dans ce cas tu n'as pas à utiliser la notation "..." car tu n'as pas de fonction à arguments variable. Tu as juste une fonction normale (toto) et un pointeur de fonction (f), qui peut ponter vers des fonctions ayant un nombre quelconque d'arguments.
 
Tu aurais besoin des "..." si ta fonction toto prenait elle-même un nombre variable d'arguments. Dans ce cas tu utiliserais les va_args dans toto. Mais même dans ce cas tu n'aurais toujours pas besoin des mettre des "..." dans la déclaration de f.

ok .... donc ca ne sert à rien alors "...", c'est juste un truc de notation ??

edit : j'aurais une autre question s'iouplé ....Est t'il possible d'accéder à la table des arguments d'une fonction ? Par exemple, imaginons que je suis dans le cas ou j'ai une fonction qui est de prototype :

donc, je lui envoie un pointeur de fonction, et params, qui est un tableau qui regroupe la liste des paramètres. Par exemple, params[0] donne le nombre d'arguments et apres, la suite du tableau sont les arguments effectifs. Par exemple :

mettons que je passe params et une fontion toto(int, int, int) à la fontcion ma_fonction_generique(). Comment faire pour récuperer dynamiquement les arguments de params et les mettre dans toto ? Y'aurait-il un truc du genre :

merci par avance

A part un gros switch bien dégueu sur le nombre de paramètres, je ne vois pas. Du coup ça limite vachement l'intérêt du callback.

 
   
 
... un switch bien dégueu serait donc la meilleure solution (et la seule) ??
 
 

Non, la meilleurs solution c'est de faire ton truc différemment. Tes fonctions f devraient elles aussi prendre un tableau params en paramètre. Ou alors un va_list.

Comment se fait-ce ...    

Tant qu'à faire dans le brutal, http://gcc.gnu.org/onlinedocs/gcc/ [...] Calls.html

+1  
 
in_your_phion:
Tu pourrais pas nous en dire plus sur ton vrai probleme ... qu'on t'aide a trouver une vraie solution?
 

merci en fait c'est ca que je veux faire Je veux juste savoir comment on fait pour passer une fonction "générique". Dans cet exemple les arguments sont tous de même type. Comment pourais t-on faire s'il ne sont pas de même type ?

merci  

__builtin_apply & consorts permet juste de trampoliner un peu plus proprement, le tripotage des arguments est dehors de sa juridiction. J'ai des doutes sur le bien fondé de votre choix de cette approche si vous ne saisissez pas le pourquoi.

 
c'est un exercice ...