j'aimerai avoir un stratagème pour appeler dynamiquement une fonction...
j'ai pensé a mettre dans un tableau, des pointeurs pointant vers les
fonctions que je veux appeler, mais je ne voit pas comment executer une
fonction en manipulant un pointeur sur elle....
[...] Les pointeurs sur des fonctions de signature differente sont *incompatibles*. Tu ne peux donc pas ranger dans le meme tableau un pointeur sur une fonction prenant un int en argument et un pointeur sur une fonction prenant un double (par exemple). Ca limite considerablement l'interet et le domaine d'application du truc.
c'est exactement sur celà que je me prend la tête depuis que j'ai tapé mon précédent post !! :'(
Je ne comprends rien :-( Tu mets tes pointeurs de fonctions dans un tableau de void * Tu déclares un typedef par type de fonctions. Tu castes au moment de l'appel (dans un switch) Ou est le problème ?
manuel leclerc
[...]
Les pointeurs sur des fonctions de signature differente
sont *incompatibles*. Tu ne peux donc pas ranger dans le
meme tableau un pointeur sur une fonction prenant un int
en argument et un pointeur sur une fonction prenant un
double (par exemple). Ca limite considerablement l'interet
et le domaine d'application du truc.
c'est exactement sur celà que je me prend la tête depuis que
j'ai tapé mon précédent post !! :'(
Je ne comprends rien :-(
Tu mets tes pointeurs de fonctions dans un tableau de void *
Tu déclares un typedef par type de fonctions.
Tu castes au moment de l'appel (dans un switch)
Ou est le problème ?
[...] Les pointeurs sur des fonctions de signature differente sont *incompatibles*. Tu ne peux donc pas ranger dans le meme tableau un pointeur sur une fonction prenant un int en argument et un pointeur sur une fonction prenant un double (par exemple). Ca limite considerablement l'interet et le domaine d'application du truc.
c'est exactement sur celà que je me prend la tête depuis que j'ai tapé mon précédent post !! :'(
Je ne comprends rien :-( Tu mets tes pointeurs de fonctions dans un tableau de void * Tu déclares un typedef par type de fonctions. Tu castes au moment de l'appel (dans un switch) Ou est le problème ?
manuel leclerc
Nicolas aunai
Emmanuel Delahaye a écrit:
typedef int puts_f (char const *s);
#include <stdio.h>
int main (void) { puts_f *pf = puts;
comment faire directement le typedef pour le pointeur ?
du style typedef <pointeur sur fonction retournant int> newtype;
void(*t[3])(int); // tableau de fonctions à parametre entier ^^^
Ha, je ne pense pas non. Un caractere accentue dans un source C, c'est pas tres portable (la preuve etant le resultat de la compilation par gcc).
<mauvaise-foi mode="moi-aussi">
Si ce n'est pas du C portable, ça ne fait pas partie du source C portable. La chaîne "// tableau de fonctions ...." est un commentaire en français intégré dans le message en marge du source, et voilà.
Et le français, portable ou pas, c'est accentué (*).
Faut être un peu logique, quand on prétend causer programmation.
</mauvaise-foi>
MB
(*) paramètre aussi, d'ailleurs. Merdoum.
-- Michel BILLAUD LABRI-Universite Bordeaux I phone W: 05 4000 6922 / 05 4000 5792 351, cours de la Liberation http://www.labri.fr/~billaud 33405 Talence (FRANCE) http://dept-info.labri.fr/~billaud
void(*t[3])(int); // tableau de fonctions à parametre entier
^^^
Ha, je ne pense pas non. Un caractere accentue dans un source C, c'est
pas tres portable (la preuve etant le resultat de la compilation par
gcc).
<mauvaise-foi mode="moi-aussi">
Si ce n'est pas du C portable, ça ne fait pas partie du source C
portable. La chaîne "// tableau de fonctions ...." est un commentaire
en français intégré dans le message en marge du source, et voilà.
Et le français, portable ou pas, c'est accentué (*).
Faut être un peu logique, quand on prétend causer programmation.
</mauvaise-foi>
MB
(*) paramètre aussi, d'ailleurs. Merdoum.
--
Michel BILLAUD billaud@labri.fr
LABRI-Universite Bordeaux I phone W: 05 4000 6922 / 05 4000 5792
351, cours de la Liberation http://www.labri.fr/~billaud
33405 Talence (FRANCE) http://dept-info.labri.fr/~billaud
void(*t[3])(int); // tableau de fonctions à parametre entier ^^^
Ha, je ne pense pas non. Un caractere accentue dans un source C, c'est pas tres portable (la preuve etant le resultat de la compilation par gcc).
<mauvaise-foi mode="moi-aussi">
Si ce n'est pas du C portable, ça ne fait pas partie du source C portable. La chaîne "// tableau de fonctions ...." est un commentaire en français intégré dans le message en marge du source, et voilà.
Et le français, portable ou pas, c'est accentué (*).
Faut être un peu logique, quand on prétend causer programmation.
</mauvaise-foi>
MB
(*) paramètre aussi, d'ailleurs. Merdoum.
-- Michel BILLAUD LABRI-Universite Bordeaux I phone W: 05 4000 6922 / 05 4000 5792 351, cours de la Liberation http://www.labri.fr/~billaud 33405 Talence (FRANCE) http://dept-info.labri.fr/~billaud
Emmanuel Delahaye
In 'fr.comp.lang.c', (Manuel Leclerc) wrote:
[...] Les pointeurs sur des fonctions de signature differente sont *incompatibles*. Tu ne peux donc pas ranger dans le meme tableau un pointeur sur une fonction prenant un int en argument et un pointeur sur une fonction prenant un double (par exemple). Ca limite considerablement l'interet et le domaine d'application du truc.
c'est exactement sur celà que je me prend la tête depuis que j'ai tapé mon précédent post !! :'(
Je ne comprends rien :-( Tu mets tes pointeurs de fonctions dans un tableau de void *
Non. void* n'est pas le bon type pour recevoir l'adresse d'une fonction.
Tu déclares un typedef par type de fonctions. Tu castes au moment de l'appel (dans un switch) Ou est le problème ?
Le problème est que ta solution invoque un comportement indéfini.
La norme est formelle là-dessus. Les pointeur sur objets et les pointeurs de fonctions ne sont pas interchangeables.
Dans la pratique, il existe des plateformes dont les pointeurs de fonctions et d'objets on des tailles différentes
- x86 mode réel en modèle de mémoire 'compact' ou 'medium'.
-- -ed- [remove YOURBRA before answering me] The C-language FAQ: http://www.eskimo.com/~scs/C-faq/top.html <blank line> FAQ de f.c.l.c : http://www.isty-info.uvsq.fr/~rumeau/fclc/
In 'fr.comp.lang.c', manuelleclerc@my-deja.com (Manuel Leclerc) wrote:
[...]
Les pointeurs sur des fonctions de signature differente
sont *incompatibles*. Tu ne peux donc pas ranger dans le
meme tableau un pointeur sur une fonction prenant un int
en argument et un pointeur sur une fonction prenant un
double (par exemple). Ca limite considerablement l'interet
et le domaine d'application du truc.
c'est exactement sur celà que je me prend la tête depuis que
j'ai tapé mon précédent post !! :'(
Je ne comprends rien :-(
Tu mets tes pointeurs de fonctions dans un tableau de void *
Non. void* n'est pas le bon type pour recevoir l'adresse d'une fonction.
Tu déclares un typedef par type de fonctions.
Tu castes au moment de l'appel (dans un switch)
Ou est le problème ?
Le problème est que ta solution invoque un comportement indéfini.
La norme est formelle là-dessus. Les pointeur sur objets et les pointeurs de
fonctions ne sont pas interchangeables.
Dans la pratique, il existe des plateformes dont les pointeurs de fonctions
et d'objets on des tailles différentes
- x86 mode réel en modèle de mémoire 'compact' ou 'medium'.
[...] Les pointeurs sur des fonctions de signature differente sont *incompatibles*. Tu ne peux donc pas ranger dans le meme tableau un pointeur sur une fonction prenant un int en argument et un pointeur sur une fonction prenant un double (par exemple). Ca limite considerablement l'interet et le domaine d'application du truc.
c'est exactement sur celà que je me prend la tête depuis que j'ai tapé mon précédent post !! :'(
Je ne comprends rien :-( Tu mets tes pointeurs de fonctions dans un tableau de void *
Non. void* n'est pas le bon type pour recevoir l'adresse d'une fonction.
Tu déclares un typedef par type de fonctions. Tu castes au moment de l'appel (dans un switch) Ou est le problème ?
Le problème est que ta solution invoque un comportement indéfini.
La norme est formelle là-dessus. Les pointeur sur objets et les pointeurs de fonctions ne sont pas interchangeables.
Dans la pratique, il existe des plateformes dont les pointeurs de fonctions et d'objets on des tailles différentes
- x86 mode réel en modèle de mémoire 'compact' ou 'medium'.
Tu mets tes pointeurs de fonctions dans un tableau de void *
Non. void* n'est pas le bon type pour recevoir l'adresse d'une fonction.
Tu déclares un typedef par type de fonctions. Tu castes au moment de l'appel (dans un switch) Où est le problème ?
Le problème est que ta solution invoque un comportement indéfini [...]
Oui, bon, tu chipotes là.
Un comportement indéfini est un bug grave. Si tu trouves que je 'chipote', change de métier avant de mettre la vie des gens en danger...
Si tu préfères, tu templaces void* par un typedef genre PFN que tu définis en fonction de ta plateforme.
Et ça change quoi? Non, il faut utiliser un pointeur de fonction. Point.
-- -ed- [remove YOURBRA before answering me] The C-language FAQ: http://www.eskimo.com/~scs/C-faq/top.html <blank line> FAQ de f.c.l.c : http://www.isty-info.uvsq.fr/~rumeau/fclc/
Michel BILLAUD
Emmanuel Delahaye writes:
In 'fr.comp.lang.c', Michel BILLAUD wrote:
Je m'étonne que personne n'ait encore cité - bien que ça concerne moins le C que les API systeme Unix - l'utilisation du chargement
Et pourquoi pas les DLL Windows...
Non. On est sur fclc. Les fonctions sysèmes sont discutées sur les groupes afférents.
Parfaitement. fr.comp.lang.c est _exactement_ l'endroit où il convient de préciser que l'usage des bibliothèques dynamiques, quoique requérant en C l'usage de pointeurs de fonction, relève d'autres groupes.
-- Michel BILLAUD LABRI-Universite Bordeaux I phone W: 05 4000 6922 / 05 4000 5792 351, cours de la Liberation http://www.labri.fr/~billaud 33405 Talence (FRANCE) http://dept-info.labri.fr/~billaud
Emmanuel Delahaye <emdelYOURBRA@noos.fr> writes:
In 'fr.comp.lang.c', Michel BILLAUD <billaud@labri.u-bordeaux.fr> wrote:
Je m'étonne que personne n'ait encore cité - bien que ça concerne
moins le C que les API systeme Unix - l'utilisation du chargement
Et pourquoi pas les DLL Windows...
Non. On est sur fclc. Les fonctions sysèmes sont discutées sur les groupes
afférents.
Parfaitement. fr.comp.lang.c est _exactement_ l'endroit où il convient
de préciser que l'usage des bibliothèques dynamiques, quoique
requérant en C l'usage de pointeurs de fonction, relève d'autres
groupes.
--
Michel BILLAUD billaud@labri.fr
LABRI-Universite Bordeaux I phone W: 05 4000 6922 / 05 4000 5792
351, cours de la Liberation http://www.labri.fr/~billaud
33405 Talence (FRANCE) http://dept-info.labri.fr/~billaud
Je m'étonne que personne n'ait encore cité - bien que ça concerne moins le C que les API systeme Unix - l'utilisation du chargement
Et pourquoi pas les DLL Windows...
Non. On est sur fclc. Les fonctions sysèmes sont discutées sur les groupes afférents.
Parfaitement. fr.comp.lang.c est _exactement_ l'endroit où il convient de préciser que l'usage des bibliothèques dynamiques, quoique requérant en C l'usage de pointeurs de fonction, relève d'autres groupes.
-- Michel BILLAUD LABRI-Universite Bordeaux I phone W: 05 4000 6922 / 05 4000 5792 351, cours de la Liberation http://www.labri.fr/~billaud 33405 Talence (FRANCE) http://dept-info.labri.fr/~billaud
Anh Vu Tran
Nicolas aunai wrote:
non mais j'aimerai bien faire une fois pour toute un type "pointeur sur fonction retournant int" pour déclarer des tableaux de ces choses... facilement.
int fct(); /* fonction retournant un int */ int (*p_fct)(); /* pointeur sur fonction retournant un int */ typedef int (*t_fct)(); /* type pointeur sur fonction retournant un int */
Anh Vu
Nicolas aunai wrote:
non mais j'aimerai bien faire une fois pour toute un type "pointeur sur
fonction retournant int" pour déclarer des tableaux de ces choses...
facilement.
int fct(); /* fonction retournant un int */
int (*p_fct)(); /* pointeur sur fonction retournant un int */
typedef int (*t_fct)(); /* type pointeur sur fonction retournant un int */
non mais j'aimerai bien faire une fois pour toute un type "pointeur sur fonction retournant int" pour déclarer des tableaux de ces choses... facilement.
int fct(); /* fonction retournant un int */ int (*p_fct)(); /* pointeur sur fonction retournant un int */ typedef int (*t_fct)(); /* type pointeur sur fonction retournant un int */
Anh Vu
manuelleclerc
Manuel Leclerc wrote:
Non mais tu t'es lu ?
Oui.
"change de métier" et "la vie des gens en danger" ???
J'ai fait des fautes d'orthographe ?
C'est ça, fait l'innocent. Puisqu'il faut te mettre les points sur les i, je trouve ta suffisance et ta grandiloquence déplacée.
<je peux le faire aussi> Un langage dont la norme prévoit explicitement le "undefined behavior" est un langage de merde </je peux le faire aussi>
Si tu n'aimes pas le C, choisit un autre langage.
J'adore le C, ce qui ne m'empèche pas de penser qu'il a certaines caractéristiques d'un autre âge. J'ai le droit ?
Je ne suis pas responsable des défauts du C.
Moi non plus. Nananère, c'est suikildikyé.
Tu avais bien vu la balise <je peux le faire aussi>, hein ?
Si tu préfères, tu remplaces void* par un typedef genre PFN que tu définis en fonction de ta plateforme.
Et ça change quoi? Non, il faut utiliser un pointeur de fonction. Point.
Si je connaît ma plateforme et mon compilateur je peux utiliser un type générique "pointeur de fonction" fourni par l'un ou l'autre (PFN, FARPROC, etc...) et je peux alors utiliser des tableaux, et des API de gestion des librairies dynamiques. Point toi même.
Si tu fais le choix délibéré d'écrire du code non portable, c'est ton problème, pas celui de fclc.
Qu'est ce que c'est que cette histoire de "problème de fclc" ?
Ecrire du code portable ce n'est pas seulement faire en sorte que le programme marche n'importe où sans aucune compilation conditionnelle. Il me semble qu'on peut s'appuyer sur un typedef dépendant de la plateforme et écrire du C portable contenant des tableaux de pointeurs de fonctions. Il y a un problème avec fclc ?
manuel leclerc
Manuel Leclerc wrote:
Non mais tu t'es lu ?
Oui.
"change de métier" et "la vie des gens en danger" ???
J'ai fait des fautes d'orthographe ?
C'est ça, fait l'innocent. Puisqu'il faut te mettre les
points sur les i, je trouve ta suffisance et ta grandiloquence
déplacée.
<je peux le faire aussi>
Un langage dont la norme prévoit explicitement le
"undefined behavior" est un langage de merde
</je peux le faire aussi>
Si tu n'aimes pas le C, choisit un autre langage.
J'adore le C, ce qui ne m'empèche pas de penser qu'il
a certaines caractéristiques d'un autre âge. J'ai le droit ?
Je ne suis pas responsable des défauts du C.
Moi non plus. Nananère, c'est suikildikyé.
Tu avais bien vu la balise <je peux le faire aussi>, hein ?
Si tu préfères, tu remplaces void* par un typedef
genre PFN que tu définis en fonction de ta plateforme.
Et ça change quoi? Non, il faut utiliser un pointeur de
fonction. Point.
Si je connaît ma plateforme et mon compilateur je peux
utiliser un type générique "pointeur de fonction" fourni par
l'un ou l'autre (PFN, FARPROC, etc...) et je peux alors
utiliser des tableaux, et des API de gestion des librairies
dynamiques. Point toi même.
Si tu fais le choix délibéré d'écrire du code non portable, c'est
ton problème, pas celui de fclc.
Qu'est ce que c'est que cette histoire de "problème de fclc" ?
Ecrire du code portable ce n'est pas seulement faire en sorte
que le programme marche n'importe où sans aucune compilation
conditionnelle. Il me semble qu'on peut s'appuyer sur un typedef
dépendant de la plateforme et écrire du C portable contenant
des tableaux de pointeurs de fonctions. Il y a un problème
avec fclc ?
"change de métier" et "la vie des gens en danger" ???
J'ai fait des fautes d'orthographe ?
C'est ça, fait l'innocent. Puisqu'il faut te mettre les points sur les i, je trouve ta suffisance et ta grandiloquence déplacée.
<je peux le faire aussi> Un langage dont la norme prévoit explicitement le "undefined behavior" est un langage de merde </je peux le faire aussi>
Si tu n'aimes pas le C, choisit un autre langage.
J'adore le C, ce qui ne m'empèche pas de penser qu'il a certaines caractéristiques d'un autre âge. J'ai le droit ?
Je ne suis pas responsable des défauts du C.
Moi non plus. Nananère, c'est suikildikyé.
Tu avais bien vu la balise <je peux le faire aussi>, hein ?
Si tu préfères, tu remplaces void* par un typedef genre PFN que tu définis en fonction de ta plateforme.
Et ça change quoi? Non, il faut utiliser un pointeur de fonction. Point.
Si je connaît ma plateforme et mon compilateur je peux utiliser un type générique "pointeur de fonction" fourni par l'un ou l'autre (PFN, FARPROC, etc...) et je peux alors utiliser des tableaux, et des API de gestion des librairies dynamiques. Point toi même.
Si tu fais le choix délibéré d'écrire du code non portable, c'est ton problème, pas celui de fclc.
Qu'est ce que c'est que cette histoire de "problème de fclc" ?
Ecrire du code portable ce n'est pas seulement faire en sorte que le programme marche n'importe où sans aucune compilation conditionnelle. Il me semble qu'on peut s'appuyer sur un typedef dépendant de la plateforme et écrire du C portable contenant des tableaux de pointeurs de fonctions. Il y a un problème avec fclc ?
