Matrice de pointeurs de fonctions

Salut,

je veux déclarer une matrice de pointeurs de fonctions puis la remplir.
Voilà comment j'ai fait ça:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

double * **F; //matrice de pointeurs de fonctions F=new double **[neq]; for(int i=1;i<=neq+1;i++) F[i]=new double *[neq];     *F[1][1]=-0.04; *F[1][2]=1.0E-4*y[3]; *F[1][3]=1.0E-4*y[2]; *F[2][1]=0.0; *F[2][2]=6.0E7*y[2]; *F[2][3]=0.0; *F[3][1]=0.04E0; *F[3][2]=-1.0E-4*y[3]-6.0E7*y[2]; *F[3][3]=1.0E4*y[2];

---

A l'exécution il plante à l'initialisation de *F[1][1]. Qu'est ce qui est faux?


De plus, je veux par la suite utiliser par exemple F[2][2] en lui passant en paramètre t et y.
Est ce que je pourrais l'appeller comme ça?

Code:

---

1 2	truc=*F[2][2](t,y);

---

1- double * ** F n'est pas une matrice de pointeurs de fonctions, mais une matrice de pointeurs sur des pointeurs de pointeurs sur des double, ce qui est nottablement différent.

2-En C les tableaux commencent à 0 et on n'a pas le droit d'ecrire derriere le dernier element...
donc
for(i=0; i<neq;++i)
plutot que for(i=0; i<=neq+1; i++)

3- *F[1][1] n'a pas été alloué encore :
tu as alloué F, F[1], mais pas le troisieme niveau d'indirection
dont on peut se demander s'il sert a quelque que chose...

4- *F[2][2] n'est pas une fonction mais un double, tu ne peut donc pas l'appeller comme une fonction...

Conclusion : Tu ne devrait pas essayer de faire du LISP ou du python plutot que du C ou du C++ ?

Si c'est bien une matrice de pointeurs de fonctions que tu veux faire, et que c'est bien du C, fonce lire un cours là-dessus !!

Tu as faux à la déclaration, à l'affectation et à l'appel (!)
Tu as de très bons cours sur le net et ailleurs ;-)

Juste un petit exemple tout simple, vu que tu n'as pas l'air d'avoir compris :

Code:

---

1 2 3 4 5 6 7 8 9 10 11

#include <stdio.h> //printf int carre(int nombre) { return nombre*nombre; }   int main(void) { int (*pFonc)(int); //déclaration du pointeur pFonc = carre; //affectation printf("Le carré de 36 est %d", pFonc(36)); //appel de carre par le pointeur pFonc return 0; }

---

Maintenant que ce soit une matrice, un tableau à 72 dimensions, c'est le même système.

Y'a un truc qui m'interesse . Ca fait peu de temps de que je sais comment marche les ptr vers fonctions et l'exemple que tu as donné leneuf22 , je l'ai compris.
Plus bas tu dis que c'est pareil pour les autres.
Donc si je veux declarer un tableau de pointeurs vers fonctions , je fais comment ? (fonctions renvoyant un int et prenant un int en param)

Code:

---

int (**ptr_fct)(int)

---

:?:

Sinon, c'est du C++ et non du C le problème que tu as ! (le mot clé "new")

Nas'

Nasky > le plus simple commence par ecrire un pointeur de fonction :

Code:

---

1 2	typedef double (*fptr)(double);

---

là un pointeur sur une fct renvoyant un double à partir d'un double...

puis tu ecris le tabelau :

Code:

---

1 2	fptr tab[52];

---

si tu le veux en une étape c'est nettement moins lisible :

Code:

---

1 2	(double (*tab)(double))[52];

---

Oui exactement, mais si tu veux un tableau au sens propre :

Code:

---

1 2	#define nelem 10 int (*ptr_fct[nelem])(int);

---

Ah merci !! Cette synthaxe :

Code:

---

(double (*tab)(double))[52];

---

je la voyais svt mais je la comprenais pas, et mtn que tu m'as ecrit le code "détaillé", je comprend mieux ;)

Citation:

---

Envoyé par leneuf22

Code:

---

int (*ptr_fct[nelem])(int);

---

---

Mais si je connais pas nb d'elements (c'est absurde puisque celui qui tape le code sait forcément le nb de fonctions normalement)mais imaginons que je ne sache pas, est-ce que ce que j'ai ecrit est bon ?

Code:

---

int (**ptr_fct)(int);

---

Et si oui, faudra t-il alloué comme si c'était un ptr vers une variable ?
Et pour ton code à toi, faudra t-il alloué pour chaque nelem, genre si c'est 10 :

Code:

---

1 2 3

for(i=0 ; i<10 ; i++) ptr_fct[i]=(int*)malloc(....);

---

Si encore oui ;), que faut-il malloc ? la taille de la fonction ?

Merci :)

Nas'

Citation:

---

Envoyé par Gandalf

Code:

---

1 2	(double (*tab)(double))[52];

---

---

Cette syntaxe me paraît louche, d'ailleurs mon compilo la refuse (LCC-Win32)

Citation:

---

Envoyé par NaskY

Mais si je connais pas nb d'elements (c'est absurde puisque celui qui tape le code sait forcément le nb de fonctions normalement)mais imaginons que je ne sache pas, est-ce que ce que j'ai ecrit est bon ?

---

Oui, c'est parfait ;-)

Citation:

---

Envoyé par NaskY

Et si oui, faudra t-il alloué comme si c'était un ptr vers une variable ?
Et pour ton code à toi, faudra t-il alloué pour chaque nelem, genre si c'est 10 :

Code:

for(i=0 ; i<10 ; i++)
ptr_fct[i]=(int*)malloc(....);

Si encore oui , que faut-il malloc ? la taille de la fonction ?

---

Non, c'est plus simple, tu as du t'emmeler là :)

Code:

---

ptr_fct = (int (**)(int))malloc(nbelems * sizeof(int (**)(int)));

---

Sachant qu'une pointeur de fonction n'est qu'un pointeur, on peut 'simplifier' l'appel en faisant (juste pour éviter de surcharger le code inutilement :

Code:

---

ptr_fct = (int (**)(int))malloc(nbelems * sizeof(void*));

---

Ensuite tu fais les affectations :

Code:

---

1 2 3

ptr_fct[i] = fonction1; //affectation resultat = ptr_fct[i](18); //appel

---

EDIT (oubli) : si le compilo connait le nombre de fonctions, tu n'as aucune allocation à faire.

Et ben! vous etes pas tendres!

Alors:

1. C'est vrai que j'aurais du mettre ce message sur le forum C++, mais il me semblait que les pointeurs de fonctions ça venait du C

2. Je n'ai jamais utilisé de pointeurs de fonctions auparavant

3. J'ai regardé les cours mais je n'ai pas trouvé d'exemple où ils créent une matrice (d'où ce message)

4. Ce que je voulais faire moi à l'origine, c'était une matrice dont chaque élément contient l'adresse d'une fonction, et on m'a dit que c'était possible avec des pointeurs de fonctions

5. Bref, je vais retourner voir les cours

Citation:

---

Envoyé par sebduth

Et ben! vous etes pas tendres!

Alors:

1. C'est vrai que j'aurais du mettre ce message sur le forum C++, mais il me semblait que les pointeurs de fonctions ça venait du C

2. Je n'ai jamais utilisé de pointeurs de fonctions auparavant

3. J'ai regardé les cours mais je n'ai pas trouvé d'exemple où ils créent une matrice (d'où ce message)

4. Ce que je voulais faire moi à l'origine, c'était une matrice dont chaque élément contient l'adresse d'une fonction, et on m'a dit que c'était possible avec des pointeurs de fonctions

5. Bref, je vais retourner voir les cours

---

le probleme c'est que tu semble mélanger C (ou C++) avec du python ou on peut crer des fonctions simples comme tu le fait, et ca ce n'est pas possible en C ou en C++.

Ben pourtant je n'ai jamais fait de python et je n'ai meme aucune idée d'à quoi ça ressemble!

Je comprends pourquoi ma déclaration était fausse. Comme je veux une matrice, j'ai commencé par déclarer une matrice, mais en fait ce sont d'abord les fonctions qu'il faut déclarer.

J'ai trouvé ça sur la FAQ :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

typedef int *(*F) (); /* F pointeur sur fonction */   int *f1() /* une fonction de type F */ { /* corps de la 1e fonction */ }   int *f2() /* une autre fonction de type F */ { /* corps de la seconde fonction */ }   int main() { F tab_fonc[2]; /* un tableau de 2 pointeurs sur fonctions (2 types F) */ int *tab;   /*initialisation du tableau de pointeurs sur fonctions */ tab_fonc[0] = f1; tab_fonc[1] = f2;   tab = tab_fonc[0](); /*appel d'une fonction */ printf("%d %d\n", tab[0], tab[1]);   tab = tab_fonc[1](); /* appel de l'autre fonction */ printf("%d %d\n", tab[0], tab[1]); return 0; }

---

Ca ressemble vraiment à ce que je veux sauf que moi la taille du tableau est dynamique, et que c'est un tableau à deux dimensions.

Mais je n'arrive pas à l'adapter! :cry:

Ben le python ca ressemble un peu à du C, mais tu peut faire des lambda-fonctions comme tu semblais vouloir en faire....

sinon par rapport a ton exemple :
F **fct_tab definit le pointeur de pointeur sur lequel tu peut construire tes tableaux de fonctions...

Ok ça y est ça marche!!

J'ai fait ça:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

typedef double (*f)(double t, double *y);   double f11(double t, double *y) { return -0.04; }   double f12(double t, double *y) { return 1.0E-4*t; }

---

puis dans le main:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

double tab; F **f; f=new F*[neq]; for(int i=1;i<=neq;i++) f[i]=new f [neq];     f[1][1]=f11; f[1][2]=f12; tab = F[1][1](0,0); /*appel d'une fonction */   printf("%f\n", tab);

---

comme tu avais dit.
Merci!

Par contre j'ai encore une petite question :lol:
Mes fonctions f11, f12,etc... seront nombreuses et ne contiennent qu'une ligne, comme dans l'exemple.

J'aimerai pouvoir les saisir directement à l'intérieur du main, avec un truc du style:
F[1][2]=1.0E-4*t; :?

Est ce qu'il y a un moyen de faire ça?

Par moment j'ai vraiment l'impression d'écrire dans le vide...

EN C LES TABLEAUX COMMENCENT A 0 ET NON A 1 !

NON EN C ON NE PEUT PAS DEFINIR DE LAMBDA FONCTIONS COMME EN PYTHON !

Je sais très bien que les tableaux en C commencent à 0!
Seulement je reprends le code de quelqu'un pour le compléter, et comme c'était une traduction de fortran (où les tableaux commencent à 1), le gars a fait commencé ses tableaux à 1.
(Ils commencent à 0 mais il ignore la première valeur).

Enfin bref, merci pour tous ces bons conseils et votre acceuil chaleureux,
maintenant ça marche!

Citation:

---

Envoyé par sebduth

Je sais très bien que les tableaux en C commencent à 0!
Seulement je reprends le code de quelqu'un pour le compléter, et comme c'était une traduction de fortran (où les tableaux commencent à 1), le gars a fait commencé ses tableaux à 1.
(Ils commencent à 0 mais il ignore la première valeur).

Enfin bref, merci pour tous ces bons conseils et votre acceuil chaleureux,
maintenant ça marche!

---

Et bien si il y a un element que tu n'utilise pas, il te faut des tableaux plus grand !

en allant de 1 à neq tu utilises neq element, or tes tableaux ont neq éléments : de 0 à neq-1...

alors soit tu fais comme f2c et tu décales ta reference, où tu alloues des tableaux plus grand d'un élément...