Passer une méthode d'une classe en argument d'une autre méthode dans une autre classe ?

Bonjour,
j'ai un petit souci :( (car suis pas bon en c++) et je suis certain de trouver ici la réponse !
voila j'ai une class :

Code:

---

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

class Find_Root { public: Find_Root(); virtual ~Find_Root(); double Root(double (*Fx)(double), double Xi, double Xf, double Precision, int MaxIter); };   double Find_Root::Root(double (*Fx)(double), double Xi, double Xf, double Precision, int MaxIter) { double solution; // trouve la solution return solution; }

---

et dans mon main une fonction f :

Code:

---

1 2 3 4 5 6 7 8 9

#include "Find_Root.h" double f(double X) return X*X+2;   int main() { Find_Root R; cout<<R.Root(f,0,5,1e-6,1000); }

---

cela me donne bien racine 2... 1.414... pas de pb la fonction f est bien transmise à Find_Root.
Le problème arrive lorsque la fonction f est définie dans une autre class et pas défini en global comme avant... J'ai donc une class nomée Fct :

Code:

---

1 2 3 4 5 6 7 8 9

class Fct { public: Fct(); virtual ~Fct(); double f(double X) return X*X+2; protected: }

---

et dans mon main je fais :

Code:

---

1 2 3 4 5 6 7

int main() { Fct Func; Find_Root R; cout<<R.Root(Func.f,0,5,1e-6,1000); }

---

ET là c'est le drame ... il reconnait pas le type de f lorsque je passe Func.f : <unresolved overloaded function type> ??? et
Impossible de compiler
||=== Build: Debug in Raccord (compiler: GNU GCC Compiler) ===|
C:\Users\jpc\Desktop\Raccord\main.cpp||In function 'int main()'|
C:\Users\jpc\Desktop\Raccord\main.cpp|44|error: no matching function for call to 'Find_Root::Root(<unresolved overloaded function type>, int, int, double, int)'|
C:\Users\jpc\Desktop\Raccord\Find_Root.h|18|note: candidate: double Find_Root::Root(double (*)(double), double, double, double, int)|
C:\Users\jpc\Desktop\Raccord\Find_Root.h|18|note: no known conversion for argument 1 from '<unresolved overloaded function type>' to 'double (*)(double)'|
||=== Build failed: 1 error(s), 0 warning(s) (0 minute(s), 1 second(s)) ===|

J'aimerais pouvoir passer à R.Root n'importe quelle fonction f qu'elle soit définie comme au début ... "double f(double X) return X*X+2;" ou dans une class quelconque pourvue qu'elle soit de type double f(double) ...

pourquoi ça ne marche pas car dans les deux cas le type de la fonction f est le même double f(double) pourtant !!?
et comment y remédier ??

Merci d'avance pour vos réponses,
cordialement
JPC

Bonjour,

Cela pourrait se résoudre avec le mot-clé static, qui permet de se passer d'une instance de la classe. Car, oui, le problème vient de là : on ne peut pas appeler Fct.f directement, il faut une instance pour pouvoir appeler la méthode.

Il faut réfléchir plus globalement sur le design. Le code n'est pas peut-être pas un code complet, mais pourquoi faire des classes ? Il n'y a pas de données membres, visiblement pas de polymorphisme (le destructeur est virtual mais ça ne sert à rien). Des namespaces avec des fonctions libres, ça serait pas suffisant ?

Exemple :

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

namespace equation {   using SolverFunction = double(double);   double find_root(SolverFunction Fx, double, double, double, int) { return Fx(0.0); }   namespace functions { double f(double X) { return X * X + 2; } }   } // namespace equation   #include <iostream>   int main() { std::cout << equation::find_root(equation::functions::f, 0, 0, 0, 0); }

---

Citation:

---

Envoyé par Bktero

Cela pourrait se résoudre avec le mot-clé static

---

Oui ! Merci pour votre réponse, mais le code n'est effectivement pas complet (loin de là)!... En fait si je déclare dans mon exemple initial :

Code:

---

1 2	static double f(double X) return X*X+2;

---

ca compile ! par contre j'ai encore un problème ... car en réalité la fonction f(double X) est plus complexe, elle fait appelle à d'autres fonctions et paramètres de la <class Fct> via le pointeur ... this->
par exemple :

Code:

---

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

class Fct { public: Fct(); virtual ~Fct(); double f(double X) {return ((this->param1) * (this-> H(X)));} double H(double X); // <---- fonction de X mais aussi des paramètres stockés dans les variables protected de la class... void Set_P1(double p1) {this->param1=p1;} protected: double param1=0.1; double param2; ... }

---

du coup si je mets

Code:

---

1 2	static double f(double X) {return ((this->param1) * (this-> H(X)));}

---

Le compilo m’envoi balader ...

"... |21|error: 'this' is unavailable for static member functions|"

je ne vois vraiment pas du tout comment m'en sortir... Merci de votre aide.

cordialement,
JP

Et c'est normal.

Il y a un problème de conception là. Une fonction libre et une méthode (non statique) d'une classe n'ont pas grand chose à voir. Tu ne peux pas atteindre l'un et l'autre à la fois. Tu as deux solutions :
- Passer un objet qui répond à une interface particulière en premier paramètre de FindRoot().
Exemple :

Code:

---

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

struct Solver { virtual double f() = 0; };   double FindRoot(Solver& s) { return s.f(); }   struct MySolver : Solver { double f() override { return 42.0f; } };   #include <iostream>   int main() { MySolver solver; std::cout << FindRoot(solver) << '\n'; }

---

- Utiliser une lambda fonction en premier argument pour wrapper l'appel à une méthode sur un objet
Exemple :

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

#include <functional>   using Solver = std::function<double(void)>;   double FindRoot(Solver s) { return s(); }   struct Fct { double f() { return 17.0; } };   #include <iostream>   int main() { Fct fct; auto wrapper = [&fct] { return fct.f(); }; std::cout << FindRoot(wrapper) << '\n'; }

---

Une fonction membre n'a pas une signature aussi simple. Ta fonction n'est pas void(*)(double) mais void(Fct::*)(double).
Pour utiliser une fonction membre en callback il faut au moins l'instance de la classe que tu ne passes même pas.
Le plus simple est sans doute d'utiliser std::function.
Ou bien le foncteur et passer la callback via template.

https://cpp.developpez.com/faq/cpp/?...qu-un-foncteur