pointeurs sur méthode

Version imprimable

Bonjour à tout le monde

en regardant des discutions récentes et en regardant un tuto sur un autre site j'ai un peu près compris les pointeurs sur fonctions mais moi je souhaite faire des pointeurs sur méthodes. Le tuto est très bien mais j'ai du mal à le mettre moi même en place sur un exemple simple.

je vous ai mis un exemple ci dessous pourriez vous s'il vous plait regarder mon code et me dire mon erreur ?
merci beaucoup

mon bout de code ?
main.cpp

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <iostream>
#include "mathematic.h"
#include "ClassPerso.h"
using namespace std;
int main()
{
    ClassPerso objetPerso;
    Mathematic mathematic;
 
    double (ClassPerso::*functionPointer)(double) = &ClassPerso::maPetiteFonction;
    double min=-2, max=5;
    double resultat=mathematic.Algo(min,max,functionPointer);
    cout << "resultat " << resultat << endl;
    return 0;
}

ClassPerso.h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
#ifndef CLASSPERSO_H
#define CLASSPERSO_H
#include "mathematic.h"
class ClassPerso
{
public:   
    ClassPerso();
    ~ClassPerso();
    double (*functionPointer)(double);
    double maPetiteFonction(double);
private:  
};
#endif // CLASSPERSO_H

mathematic.h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
#ifndef MATHEMATIC_H
#define MATHEMATIC_H
#include "ClassPerso.h"
class Mathematic
{
public:
    Mathematic();
    ~Mathematic();
    double Algo(double &,double &,double (ClassPerso::*functionPointer)(double));
private:
};
#endif // MATHEMATIC_H

ClassPerso.cpp

Code:

1
2
3
4
5
6
7
8
9
10
11
#include <iostream>
#include <math.h>
#include "ClassPerso.h"
#include "mathematic.h"
using namespace std;
ClassPerso::ClassPerso(){}
ClassPerso::~ClassPerso() {}
double ClassPerso::maPetiteFonction(double x)
{
    return x-cos(x)+sin(x);
}

mathematic.cpp

Code:

1
2
3
4
5
6
7
8
9
10
11
12
#include <iostream>
#include <math.h>
#include "ClassPerso.h"
#include "mathematic.h"
using namespace std;
Mathematic::Mathematic() {}
Mathematic::~Mathematic() {}
double Mathematic::Algo(double &min,double &max,double (*ClassPerso::*f)(double))
{
    double b=f(min)+f(max);
    return b;
}

06/10/2012, 13h06
Neckara
Bonjour,

Ta méthode Algo n'a pas le même prototype dans le .h et le .cpp
Ensuite, pour utiliser un pointeur sur méthode, il faut avoir une instance de la classe :
Code:

1 2 3 MaClasse * c; MonPtrMethode m = &MaClasse::methode; (c->*m)();//appel de la méthode.
Sinon en fonction de ce que tu veux faire, tu peux aussi utiliser des objets-fonctions.

Bonjour Neckara et merci pour ta réponse

Citation:

Envoyé par Neckara

Ta méthode Algo n'a pas le même prototype dans le .h et le .cpp

en effet, je viens de mettre dans le .h ce prototype :

Code:

double Mathematic::Algo(double &min,double &max,double (*ClassPerso::*f)(double));
Citation:
Envoyé par Neckara
Ensuite, pour utiliser un pointeur sur méthode, il faut avoir une instance de la classe :
Code:

1 2 3 MaClasse * c; MonPtrMethode m = &MaClasse::methode; (c->*m)();//appel de la méthode.
ah ok, je vois ce que tu veux dire :ccool:
du coup, j'ai changé mon main.cpp et voici ce que j'ai :
Code:

1 2 3 4 5 ClassPerso objetPerso; Mathematic mathematic; double (ClassPerso::*functionPointer)(double) = &ClassPerso::maPetiteFonction; double min=-2, max=5; double resultat=mathematic.Algo(min,max,objetPerso->functionPointer);
par contre il me reste un truc à débloquer car voici ce que j'ai comme erreur (image en PJ)

Citation:

Envoyé par Neckara

Sinon en fonction de ce que tu veux faire, tu peux aussi utiliser des objets-fonctions.

c'est les foncteurs c'est ça ?
je viens de voir ceci sur une autre discussion (celle qui m'a inspirée à écrire ce message) mais j'avous ne pas comprendre l'intérêt des foncteurs.
ça me paraît beaucoup moins naturel que le pointeurs sur fonctions et je ne saisi pas l'intérêt...

06/10/2012, 13h37
Neckara

Si tu n'as pas de pointeur sur ta classe, c'est :

Code:

(c.*m)();

Pour passer en paramètre :

Code:

double (ClassPerso::*f)(double)

Les foncteurs peuvent faire plus de choses comme enregistrer des paramètres. Très utile quand on utilise for_each ou d'autres algorithles du même genre.

merci beaucoup Nekara mais je n'ai pas compris ce que tu voulais dire...
surtout

Code:

(c*.m)()

voici où j'en suis (pourrais tu me dire où placer ce que tu m'as dis car je ne vois pas ce que tu veux dire):
main.cpp

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <iostream>
#include "mathematic.h"
#include "ClassPerso.h"
using namespace std;
int main()
{
    ClassPerso objetPerso;
    Mathematic mathematic;
    double (ClassPerso::*functionPointer)(double) = &ClassPerso::maPetiteFonction;
    double min=-2, max=5;
    double resultat=mathematic.Algo(min,max,objetPerso.functionPointer);
    cout << "resultat " << resultat << endl;
    return 0;
}

ClassPerso.h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
#ifndef CLASSPERSO_H
#define CLASSPERSO_H
#include "mathematic.h"
class ClassPerso
{
public:
    ClassPerso();
    ~ClassPerso();
    double (*functionPointer)(double);
    double maPetiteFonction(double);
private:
};
#endif // CLASSPERSO_H

ClassPerso.cpp

Code:

1
2
3
4
5
6
7
8
9
10
11
#include <iostream>
#include <math.h>
#include "ClassPerso.h"
#include "mathematic.h"
using namespace std;
ClassPerso::ClassPerso(){}
ClassPerso::~ClassPerso() {}
double ClassPerso::maPetiteFonction(double x)
{
    return x-cos(x)+sin(x);
}

mathematic.h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
#ifndef MATHEMATIC_H
#define MATHEMATIC_H
#include "ClassPerso.h"
class Mathematic
{
public:
    Mathematic();
    ~Mathematic();
    double Mathematic::Algo(double &min,double &max,double (ClassPerso::*f)(double));
private:
};
#endif // MATHEMATIC_H

mathematic.cpp

Code:

1
2
3
4
5
6
7
8
9
10
11
12
#include <iostream>
#include <math.h>
#include "ClassPerso.h"
#include "mathematic.h"
using namespace std;
Mathematic::Mathematic() {}
Mathematic::~Mathematic() {}
double Mathematic::Algo(double &min,double &max,double (ClassPerso::*f)(double))
{
    double b=f(min)+f(max);
    return b;
}

06/10/2012, 14h32
Neckara
Quand tu veux passer un pointeur sur méthode à une fonction, il faut lui donner le pointeur sur la méthode ici functionPointer.

Mais il faut que ta fonction ai une instance de la classe pour pouvoir appeler la méthode, donc soit elle construit une instance de la classe, soit on lui donne une instance de la classe :
Code:

1 2 3 4 5 6 7 8 9 void fct(MonPointeur * ptr) { Classe classe; (classe.*ptr)(); } typedef void (Classe::*MonPointeur)(void); MonPointeur ptr = &Classe::methode; fct(ptr);
06/10/2012, 14h38
didierBB

en fait Neckara j'ai du mal avec toutes ces notions donc c'est pour ceci que je voudrais voir où cela s'insert dans mon code pour bien visualiser par rapport à une basse connue.

ce que tu me dis se placerai où ?

dans ClassPerso.h ? tout à la suite ?

ça me parait bizarre d'avoir encore à définir un objet alors que dans le main.cpp j'en ai deja un de declaré ?
06/10/2012, 14h41
Neckara
Code:

1 2 3 4 5 void fct(MonPointeur * ptr) { Classe classe; (classe.*ptr)(); }
Tu passes à fct un pointeur sur méthode et tu utilises le pointeur sur méthode, cela correspond donc à ta méthode Algo.
Code:

1 2 3 typedef void (Classe::*MonPointeur)(void); MonPointeur ptr = &Classe::methode; fct(ptr);
Ici tu appelles la fonction fct, ce qui correspond à l'appel de la méthode Algo.

Neckara, j'ai vraiment du mal à raccrocher tous les bout que tu me donnes car j'ai du mal à me plonger dans ton code.

le mieux serait que tu me montre sur mon bout de code car ça me permet de partir d'une base que je connais et de voir ce que les pointeurs sur fonctions modifient.
Lorsque tu me montre sur un de tes exemples j'ai une difficulté en plus pour comprendre à quoi ça correspond sur mon code et du coup je me perds (je suis débutant).

en fait j'aimerai commencer sans les "typdef" afin de bien comprendre.
Ensuite, lorsque je comprendrai j'utiliserai les "typdef".

Voici où j'en suis dans mon code, peux tu ce qui ne va pas s'il te plait sur mon code ?
main.cpp
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 #include <iostream> #include "mathematic.h" #include "ClassPerso.h" using namespace std; int main() { ClassPerso objetPerso; Mathematic mathematic; double (ClassPerso::*functionPointer)(double) = &ClassPerso::maPetiteFonction; double min=-2,max=5; double resultat=mathematic.Algo(min,max,functionPointer,objetPerso); cout << "resultat " << resultat << endl; return 0; }
ClassPerso.h
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 #ifndef CLASSPERSO_H #define CLASSPERSO_H #include "mathematic.h" class ClassPerso { public: ClassPerso(); ~ClassPerso(); double (*functionPointer)(double); double maPetiteFonction(double); private: }; #endif // CLASSPERSO_H
ClassPerso.cpp
Code:

1 2 3 4 5 6 7 8 9 10 11 12 #include <iostream> #include <math.h> #include "ClassPerso.h" #include "mathematic.h" using namespace std; ClassPerso::ClassPerso(){} ClassPerso::~ClassPerso() {} double ClassPerso::maPetiteFonction(double x) { return x-cos(x)+sin(x); }
mathematic.h
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 #ifndef MATHEMATIC_H #define MATHEMATIC_H #include "ClassPerso.h" class Mathematic { public: Mathematic(); ~Mathematic(); double Mathematic::Algo(double &min,double &max,double (ClassPerso::functionPointer *f)(),ClassPerso &); private: }; #endif // MATHEMATIC_H
mathematic.cpp
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 #include <iostream> #include <math.h> #include "ClassPerso.h" #include "mathematic.h" using namespace std; Mathematic::Mathematic() {} Mathematic::~Mathematic() {} double Mathematic::Algo(double &min,double &max,double (ClassPerso::functionPointer *f)(),ClassPerso &) { double b=_objet.*f(min)+_objet.*f(max); return b; }

Bonjour,

Juste pour illustrer les propos de Neckara,

La version à base de foncteur :

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
 
 
#include <iostream>
#include <cmath>
 
struct FoncteurPerso {
 
	double operator () (double x) const 
	{
		return x-cos(x)+sin(x);
	}
 
};
 
 
class Mathematic {
public:
	template < typename FoncteurType >
	double Algo(double &min,double &max, FoncteurType f )
	{
		double b=f(min)+f(max);
		return b;
	}
};
 
int main( int argc, char *argv[] ){
	FoncteurPerso foncteurPerso;
	Mathematic mathematic;
	double min=-2, max=5;
	double resultat=mathematic.Algo(min,max,foncteurPerso);
	std::cout << "resultat " << resultat << std::endl;
	return 0;
}

Une autre à base de méthode virtuelle :

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
 
#include <iostream>
#include <cmath>
 
class AbstractMethod {
public:
	virtual ~AbstractMethod(){}
	virtual double operator() ( double x ) const = 0 ;
};
 
 
class MethodPerso : public AbstractMethod {
public:
	virtual double operator () (double x) const 
	{
		return x-cos(x)+sin(x);
	}
 
};
 
 
class Mathematic {
public:
	double Algo(double &min,double &max, AbstractMethod & f )
	{
		double b=f(min)+f(max);
		return b;
	}
};
 
int main( int argc, char *argv[] ){
	MethodPerso methodPerso;
	Mathematic mathematic;
	double min=-2, max=5;
	double resultat=mathematic.Algo(min,max,methodPerso);
	std::cout << "resultat " << resultat << std::endl;
	return 0;
}

PS : L'usage de pointeurs de fonction est surtout nécessaire en C. En C++, c'est un peu sale... Si vous voulez vraiment un équivalent en C++, je pense qu'il vous faut regarder du côté de boost::bind, plutôt que de vous battre avec des syntaxes affreuses. Ça doit d'ailleurs être dans C++11.

probleme résolu ! merci beaucoup :

main.cpp :

Code:

1
2
    double (ClassPerso::*f)(double) = &ClassPerso::maPetiteFonction;
    double resultat=mathematic.algo(-2,5,f,objetPerso);

mathematic.cpp :

Code:

1
2
3
4
5
double Mathematic::algo(double min, double max, double(ClassPerso::*f)(double), ClassPerso &objet)
{
    double b=(objet.*f)(min)+(objet.*f)(max);
    return b;
}

A+ et merci pour votre participation :ccool: