pointeurs sur fonction

j'ai un bout de code qui est le suivant:

Code:

---

1 2	float rtnewt (void *(func)(float,float*,float*),float x1,float x2)

---

puis l'appel de la fonction func:

Code:

---

1 2	(*func)(x,&fl,&df);

---

plus précisement, func est une "user-defined function" mathématique qui renvoie la valeur de cette fonction et sa dérivée en x.
mes quelques connaissances en c++ me disent qu'il s'agit d'un pointeur sur fonction qui ne renvoie rien, et qui modifie fl et fd et qui passe par parametre x.
maintenant, comment créer cette fonction func
on peut prendre un exemple avec la fonction exponentielle.

Code:

---

1 2 3 4 5 6 7 8 9

void *func(){ double *fl; double *df; fl=exp(x); df=(exp(x+0.01)-exp(x-0.01))/0.02;     }

---

mon pb est que je ne sais pas quoi mettre dans func().
je ne comprends pas bien la structure de func

Code:

---

1 2 3 4 5 6 7 8 9 10 11

float rtnewt(void (*func)(float, float*, float*), float x1, float x2);   void exponentielle(float x, float* fl, float* df) { *fl = exp(x); *df = (exp(x + 0.01) - exp(x - 0.01)) / 0.02; }   float x1 = ...: float x2 = ...; float resultat = rtnewt(&exponentielle, x1, x2);

---

merci j'ai quelques questions:
*func :il s'agit bien d'un pointeur sur fonction?

Code:

---

1 2	float rtnewt(void (*func)(float, float*, float*), float x1, float x2);

---

qu'est ce que tu définis ici? Est-ce un prototype de la fonction rtnew?

Code:

---

1 2 3 4 5 6 7

void exponentielle(float x, float* fl, float* df) { *fl = exp(x); *df = (exp(x + 0.01) - exp(x - 0.01)) / 0.02; }

---

pourquoi tu passes comme arguments fl et df alors qu'ils vont être modifies?
fl est df sont des pointeurs sur des float.
pourquoi on aurait pas pu faire:
void exponentielle(float x)

si on mettait:

Code:

---

1 2 3 4 5 6 7

void exponentielle(float x, float fl, float df) { fl = exp(x); df = (exp(x + 0.01) - exp(x - 0.01)) / 0.02; }

---

alors fl et df seraient modifies a l'intérieur de la fonction, mais pas a l'extérieur de la fonction.

Citation:

---

*func :il s'agit bien d'un pointeur sur fonction?

---

Oui (enfin, sans l'étoile).

Citation:

---

qu'est ce que tu définis ici? Est-ce un prototype de la fonction rtnew?

---

Oui (le tien n'était pas correct, donc je l'ai corrigé).

Citation:

---

pourquoi tu passes comme arguments fl et df alors qu'ils vont être modifies?

---

Comment veux-tu les modifier si tu ne les passes pas à la fonction ?

Citation:

---

pourquoi on aurait pas pu faire:
void exponentielle(float x)

---

Et comment tu récupères les résultats ?
De toute façon rtnewt attend un void (*)(float, float*, float*), pas un void (*)(float).

Citation:

---

alors fl et df seraient modifies a l'intérieur de la fonction, mais pas a l'extérieur de la fonction

---

Oui.

Citation:

---

Envoyé par Laurent Gomila

Code:

---

1 2 3 4 5 6

void exponentielle(float x, float* fl, float* df) { *fl = exp(x); *df = (exp(x + 0.01) - exp(x - 0.01)) / 0.02; }

---

---

Détail qui n'a rien à voir avec le C++, mais avec les math : Si on donne l'opportunité à l'utilisateur de rtnewt de définir lui même la valeur de la dérivée, c'est bien pour éviter d'utiliser des approximations dans les cas nombreux où l'on peut faire mieux. Donc, ici, j'écrirais :

Code:

---

1 2 3 4 5 6

void exponentielle(float x, float* fl, float* df) { *fl = exp(x); *df = *fl; }

---

ok, mais a quoi sert df alors?
je comprends pas ce que tu ecrits:

df et fl auront les meme valeurs


Et comment tu récupères les résultats ?
les resultats sont accesibles dans l'espace memoire, grace a &

pour que ce soit plus compréhensible, je vous envoie le code source
en entier
il s'agit de la methode de newton pour la resolution d'equations.
quand je compile, le compilateur me repond:

& requires l-value

qu'est ce qu'une l-value?

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 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44

#include <stdio.h> #include <iostream> #include <math.h> #include <string> #define JMAX 20 using namespace std;     void exponentielle(float x, float* fl, float* df) { *fl = exp(x); *df = (exp(x + 0.01) - exp(x - 0.01)) / 0.02; }     float rtnewt (void (*func)(float,float *,float *),float x1,float x2,float xacc){ int j; float df,dx,f,rtn; rtn=0.5*(x1+x2);   for(j=1;j<=JMAX;j++){ (*func)(rtn,&f,&df); dx=f/df; if((x1-rtn)*(rtn-x2)<0.0) cout<<"e"; if (fabs(dx)<xacc) return rtn; } return 0; }   int main(){ float x1=-10; float x2=10; float prec=0.001;   float x=1; float* y=0; float* z=0; rtnewt(&exponentielle(x,y,z),x1,x2,prec);   }

---

Citation:

---

ok, mais a quoi sert df alors?
je comprends pas ce que tu ecrits:

df et fl auront les meme valeurs

---

La dérivée d'exponentielle, c'est exponentielle. D'où l'optimisation consistant à placer dans df la même valeur que fl, pas besoin de calculer une dérivée classique.

Citation:

---

les resultats sont accesibles dans l'espace memoire, grace a &

---

Ca veut rien dire...

Citation:

---

Code:

---

rtnewt(&exponentielle(x,y,z),x1,x2,prec);

---

---

Là il faut passer l'adresse de la fonction exponentielle, pas l'appeler avec des paramètres (c'est e qui provoque ton erreur de compilation). Regarde encore une fois mon code plus haut.

Une l-value est une valeur affectable: Une valeur pouvant être à gauche ("left" en anglais) d'un signe =.

Ta ligne rtnewt(&exponentielle(x,y,z),x1,x2,prec); est incorrecte, car tu tentes de passer l'adresse d'une valeur retournée par l'appel exponentielle(x,y,z).
Essaie ceci:

Code:

---

rtnewt(&exponentielle, x1, x2, prec);

---

ce que je ne comprends tj pas c'est pourquoi utiliser la fonction avec un pointeur.
pour moi, si on appelle la fonction sans paser par les pointeurs, et qu'on modifie les variables a l'intérieur d'une fonction dans la memoire, on pourra toujours acceder a ces variablea ailleurs que dans la fonction.

Ben non. En C et C++, le passage de paramètre se fait par valeur : La fonction ne manipule qu'une copie des variables, les modifications ne sont pas reportées.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

void MauvaisEchange(int a, int b) { int tmp = a; a = b; b = tmp; }   void BonEchange(int *pa, int *pb) { int tmp = *pa; *pa = *pb; *pb = tmp; }   int main(void) { int var1 = 1, var2 = 2, var3 = 3, var4 = 4; MauvaisEchange(var1, var2); BonEchange(&var3, &var4); std::cout << var1 << var2 << var3 << var4 << std::endl; return 0; }

---

Et là, tu verras que seuls var3 et var4 ont été modifiés.

Toutefois, en C++, un nouveau type de passage de paramètres a été créé, le passage par référence :

Code:

---

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

void BonEchangeParRef(int &a, int &b) { int tmp = a; a = b; b = tmp; }   int main(void) { int var5 = 5, var6 = 6; BonEchangeParRef(var5, var6); std::cout << var5 << var6 << std::endl; return 0; }

---

Ce qui pour tes fonctions donnerait :

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 29 30 31 32 33 34 35 36 37 38 39 40

#include <iostream> #include <cmath> #include <string> #define JMAX 20 using namespace std;     void exponentielle(float x, float & fl, float & df) { fl = exp(x); df = (exp(x + 0.01) - exp(x - 0.01)) / 0.02; }     float rtnewt (void (*func)(float,float &,float &), float x1, float x2, float xacc) { int j; float df,dx,f,rtn; rtn=0.5*(x1+x2);   for(j=1;j<=JMAX;j++) { (*func)(rtn,f,df); dx=f/df; if((x1-rtn)*(rtn-x2)<0.0) cout<<"e"; if (fabs(dx)<xacc) return rtn; } return 0; }   int main() { float x1=-10; float x2=10; float prec=0.001;   rtnewt(&exponentielle, x1, x2, prec); return 0; }

---

Ben non. En C et C++, le passage de paramètre se fait par valeur : La fonction ne manipule qu'une copie des variables, les modifications ne sont pas reportées.

ca j'ai compris
je pense que je me suis mal exprimé

quand on pointe sur une fonction, on pointe sur quoi en realité?

PENSER AUX BALISES [quote] / [/quote]

Dans le cas d'une fonction libre ou d'une fonction membre non-virtuelle, un pointeur de fonction pointe généralement sur le début de son code, je pense...
Mais au niveau source, cela n'a pas vraiment d'importance...

Code:

---

1 2	void (* func)(float,float&,float&);

---

Déclare 'func' comme un "pointeur" de fonction prennant (float,float&,float&) comme arguments, et ne renvoyant rien...

Code:

---

1 2	float rtnewt (void *(func)(float,float&,float&),float x1,float x2)

---

Déclare 'rtnewt' comme une fonction ayant besoin de trois paramètres:
Une fonction (de type 'func' voir au dessus), et deux floats.

Code:

---

1 2 3 4 5 6 7 8 9 10 11

void exponentielle (float x, float& fl, float& df) { df = fl = expf(x); }   void logarithm (float x, float& fl, float& df) { fl = logf(x); df = 1.0f/x; }

---

"exponentielle" et "logarithm" sont toutes deux des fonctions de type "func"... Et donc peuvent être passées en premier paramètre de "rtnewt".

Comme quand tu écris:

Code:

---

1 2	float toto;

---

"toto" est de type "float"

et bien...

Code:

---

1 2 3 4 5 6

void logarithm (float x, float& fl, float& df) { fl = logf(x); df = 1.0f/x; }

---

"logarithm" est de type "void (*)(float,float&,float&)"

ok merci
mais quelle est la différence entre :

Code:

---

1 2 3 4

void (* func)(float,float&,float&);   float rtnewt (void *(func)(float,float&,float&),float x1,float x2)

---

et

Code:

---

1 2 3 4

void ( func)(float,float&,float&);   float rtnewt (void (func)(float,float&,float&),float x1,float x2)

---

ce n'est pas moi qui est le code que j'ai envoyé
mais c'est le deuxieme cas que j'aurais fait.

le '*'

:dehors:

merci

Attention, void * (func)(...) et void (*func)(...) ne sont pas du tout la même chose.

• Je suis surpris que le premier compile si tu mets ce type directement en paramètre, car il y manque la notion de pointeur de fonction: Il y a plus une notion de fonction retournant un pointeur.
• Le second, lui, est bien un pointeur de fonction ne retournant rien.