Discussion :

[sebduth]

Salut,

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[Gandalf]

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++ ?

[leneuf22]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[Nasky]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

int (**ptr_fct)(int)

:

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

Nas'

[Gandalf]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
fptr tab[52];

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[leneuf22]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[Nasky]

Ah merci !! Cette synthaxe :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

(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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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'

[leneuf22]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

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

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 ;-)

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

Ensuite tu fais les affectations :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[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

[Gandalf]

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++.

[sebduth]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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!

[Gandalf]

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...

[sebduth]

Ok ça y est ça marche!!

J'ai fait ça:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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
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?

[Gandalf]

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 !

[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!

[Gandalf]

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...