Discussion :

[deubelte]

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

Code :

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

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

puis l'appel de la fonction func:

Code :

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

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 :

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

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

[Laurent Gomila]

Code :

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

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

[deubelte]

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

Code :

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

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 :

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

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 :

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

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.

[Laurent Gomila]

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

Oui (enfin, sans l'étoile).

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

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 ?

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

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

Oui.

[JolyLoic]

Code :

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

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 :

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

1
2
3
4
5
6
 
void exponentielle(float x, float* fl, float* df)
{
    *fl = exp(x);
    *df = *fl; 
}

[deubelte]

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 &

[deubelte]

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 :

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

[Laurent Gomila]

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.

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

Ca veut rien dire...

Code :

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

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.

[Médinoc]

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 :

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

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

[deubelte]

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.

[Médinoc]

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 :

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

[Médinoc]

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

Code :

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

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 :

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

[deubelte]

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

[Médinoc]

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

[nicroman]

Code :

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

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 :

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

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 :

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

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 :

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

1
2
 
float  toto;

"toto" est de type "float"

et bien...

Code :

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

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&)"

[deubelte]

ok merci
mais quelle est la différence entre :

Code :

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

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

et

Code :

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

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.

[nicroman]

le '*'

[deubelte]

merci

[Médinoc]

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.