Discussion :

[didierBB]

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 :

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

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 :

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

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 :

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

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 :

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

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 :

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

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

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

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

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.

[didierBB]

Bonjour Neckara et merci pour ta réponse

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 :

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

double Mathematic::Algo(double &min,double &max,double (*ClassPerso::*f)(double));

Ensuite, pour utiliser un pointeur sur méthode, il faut avoir une instance de la classe :

Code :

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

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
du coup, j'ai changé mon main.cpp et voici ce que j'ai :

Code :

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

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)

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

[Neckara]

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

Code :

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

(c.*m)();

Pour passer en paramètre :

Code :

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

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.

[didierBB]

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

Code :

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

(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 :

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

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 :

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

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 :

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

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 :

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

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 :

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

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

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

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

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

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

[Neckara]

Code :

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

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 :

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

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.

[didierBB]

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 :

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

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 :

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

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 :

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

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 :

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

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 :

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

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

[bretus]

Bonjour,

Juste pour illustrer les propos de Neckara,

La version à base de foncteur :

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
 
 
#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 :

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

[didierBB]

probleme résolu ! merci beaucoup :

main.cpp :

Code :

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

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

mathematic.cpp :

Code :

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

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