Pointeur de function et methode de classe

Bonjour,

J'ai défini un namespace comportant tout un ensemble de fonctions numériques dont certaines prennent des fonctions en arguments:

Code:

---

1 2 3 4 5 6 7

namespace numeric { void f1(); void f2(); // ... double integration(double (*func)(double)); }

---

Ensuite dans une class C j'ai:

Code:

---

1 2 3 4 5 6 7 8 9

using namespace numeric;   class C { // .... double function(double d); void example();   }

---

Code:

---

1 2 3 4

void C::example() { double d = integration(function); // ERROR }

---

Le problème est que dans la fonction example, là où on attend du double (*)double on reçoit du double ( C:: )double, d'où erreur à la compilation.

Ainsi, je peux régler cela en modifiant la fonction function en en faisant une fonction libre en dehors de la classe C.
Cela compile mais je n'ai plus accès aux variables membres de la classe C (j'en ai besoin).

J'ai essayé d'utiliser les template sans succès (error:<unresolved overloaded function type>).
J'ai réfléchi à utiliser une fonction membre static mais cela impliques des variables static aussi.

Vous l'aurez compris, je cherche un moyen de passer par arguments des méthodes membres à une fonction libre (définie dans un fichier et namespace à part).

Merci de votre aide.

EDIT 1
J'ai trouvé une solution pour effectuer l'appel en changeant la signature de integration:

Code:

---

1 2 3 4 5 6 7 8 9

class C;   namespace numeric { void f1(); void f2(); // ... double integration(double (C::*func)(double)); }

---

Par contre dans le corps de integration, je n'arrive plus à appeler la fonction en argument:

Code:

---

1 2 3 4 5

double integration(double (C::*func)(double)) { double x = ....; double f = (*func)(x); // NE MARCHE PLUS }

---

Il faut modifié l'appel mais je vois pas comment.

EDIT 2

Logiquement je pensais que cela devait être:

Code:

---

double f = (C.*func)(x);

---

Mais ça ne marche pas non plus

Code:

---

error: expected primary-expression before ‘.*’ token

---

Mais C::function() prend deux arguments : un C* caché et un double.

En fait pour que cela marche je pense qu'il me faudrait une instance:

Code:

---

1 2 3 4

double integration(double (C::*func)(double), C obj) { double f = (obj.*func)(x); }

---

Mais je souhaiterai éviter cela et garder la signature:

Code:

---

double integration(double (C::*func)(double));

---

EDIT
J'ai vu la manière de faire suivante:

Code:

---

double f = (*this.*func)(x);

---

Mais dans mon cas this n'as pas de sens car il s'agit d'une fonction libre (pas de classe), et donc j'ai le mesage d'erreur suivant:

Code:

---

error: invalid use of ‘this’ in non-member function

---

Essaie d'utiliser un type template en guise de fonction.
L'intérêt, c'est que tu pourras lui donner un foncteur.

exemple de foncteur (un peu a l'ancienne):

Code:

---

1 2 3 4 5 6 7

class Fonction { private: C const& ref public: Fonction(C const& ref) : ref(ref) {} double Fonction(double d) const {return ref.function(d);} };

---

En fait, il s'agit grosso modo de ce que fait/faisait std::mem_fun
Ca peut certainement se remplacer par une lambda, mais je ne sais plus l'écrire

En C++11, tu peux passer une lambda :

Code:

---

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

// g++ -Wall -Wextra -Wconversion -Wsign-conversion -std=c++11 -pedantic main.cpp -o main && ./main   #include <iostream>   class C { public:   void function(double const d) const { std::cout << "C::function(" << d << ")" << std::endl; } };   template <class fct_t> void integration(fct_t && f) { f(21.42); }   int main() { integration([](double const d) { C().function(d); });   return 0; }

---

Merci de votre aide.

Je dois rester en C++98, du coup je vais plutôt m'orienter du côté du foncteur, par contre j'ai pas bien compris dans mon cas ce que je dois faire.

J'ai d'une part des fonctions libres .h/.cpp

Code:

---

1 2 3 4 5

namespace numeric { void f1(); ... }

---

Et de l'autre une classe C

Code:

---

1 2 3

class C { }

---

Je dois définir le foncteur où?

:f1:
http://cpp.developpez.com/faq/cpp/?p...ur-de-fonction
et sujet maintes et maintes fois abordés sur ce forum qui dispose d'une recherche
http://www.developpez.net/forums/d15...ion-structure/
http://www.developpez.net/forums/d15...ers-fonctions/
http://www.developpez.net/forums/d14...nction-membre/

Et en utilisant une fonction copine? :koi:, si j'ai bien compris ton problème


Code approximatif: :wow:

Code:

---

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

void g_callback(A& a) { a.dummy = 5; }     class A { friend void g_callback(A& a);   public:   A() : dummy(0) {}   private:   int dummy; };

---

Il me semble que le friend ne sert qu'entre deux classes, alors quen occurence ici j'ai qu'une classe d'un côté un des fonctions libres de l'autre.

Citation:

---

Envoyé par LinuxUser

Il me semble que le friend ne sert qu'entre deux classes, alors quen occurence ici j'ai qu'une classe d'un côté un des fonctions libres de l'autre.

---

nop.

Mais le problème n'est pas même déplacé : la fonction libre a besoin d'une instance.

La lambda de C++11 n'est pas obligatoire, on peut utiliser la même astuce avec C++98, avec ou sans Boost

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

// g++ -Wall -Wextra -Wconversion -Wsign-conversion -std=c++98 -pedantic main.cpp -o main && ./main   #include <iostream> #include <functional> #include <boost/bind.hpp>   class C { public:   void function(double const d) const { std::cout << "C::function(" << d << ")" << std::endl; } };   template <class fct_t> void integration(fct_t const & f) { f(21.42); }   int main() { // C++11 (lambda) // integration([](double const d) { C().function(d); });   // C++98 { C c; integration(std::bind1st(std::mem_fun(&C::function), &c)); }   // C++98 avec Boost { C c; integration(boost::bind(&C::function, &c, _1)); }   return 0; }

---

Bonjour,

Tentative avec une approche compatible Lambda, foncteur, bind, etc. :

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 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60

#include <iostream>   /**  * integration sur [0,1]  */ template < typename F > double integration( F f, const int & N = 100 ){ const double start = 0.0 ; const double end = 1.0 ;   double result = 0.0 ; double dx = (end-start) / ( N - 1 ) ; for ( int i = 0; i < N-1; i++ ){ double x1 = start + i * dx ; double x2 = start + (i+1) * dx ; result += 0.5 * ( f(x1) + f(x2) ) * dx ; } return result ; }   struct One { double operator () ( double /*x*/ ) const { return 1.0; } } ;   struct Identity { double operator () ( double x ) const { return x ; } } ;     double square( double x ){ return x * x ; }   // g++ -Wall --std=c++11 -o integration main.cpp && integration.exe int main( int argc, char* argv[] ){ { One f; std::cout << "integration(One) : " << integration(f) << std::endl ; std::cout << "attendu : " << 1.0 << std::endl; } { Identity f; std::cout << "integration(Identity) : " << integration(f) << std::endl ; } { std::cout << "integration(Square) : " << integration(square) << std::endl ; } { std::cout << "integration(Cube) : " << integration( [] (double x) -> double { return x*x*x; }) << std::endl ; } return 0 ; }

---

Hello

Si ta fonction a besoin d'une instance, ce n'est pas une fonction libre ! Si tu tiens à ce que tes fonctions soient membres d'une classe mais puissent être appelées sans instance, alors tu as un problème de conception, tu cherches à résoudre un problème de la mauvaise manière.

Salut,

Je pense être malheureusement arrivé à la même conclusion :?
Du coup , soit je revois le design, soit j'essaye de trouver une solution technique au problème.

Tu pourrais --- mais c'est bancal, non réentrant, peu maintenable, peu compréhensible --- ajouter à C un membre statique qui servirait à mémoriser l'instance en question :

Code:

---

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

namespace ns { double functor(double (*f)(double)); }   class C { static const C* _instance; double f_impl(double) const; public: static double f(double d) { return _instance->f_impl(d); } void exemple(void) { _instance = this; ns::functor(f); } };

---

J'ai du mal à voir où tu veux en venir, car l'instance on en a besoin dans la fonction libre, pas dans la classe elle-même.
Par contre l'idée d'instance static j'y avais pensé en faisant un genre de singleton que je récupèrerais via une variable globale (commune à la fonction libre et la classe instanciant la classe C), mais bon je m'égare là c'est mal.

Citation:

---

Envoyé par LinuxUser

J'ai du mal à voir où tu veux en venir, car l'instance on en a besoin dans la fonction libre, pas dans la classe elle-même.
Par contre l'idée d'instance static j'y avais pensé en faisant un genre de singleton que je récupèrerais via une variable globale (commune à la fonction libre et la classe instanciant la classe C), mais bon je m'égare là c'est mal.

---

Je te fais confiance pour adapter : plutôt qu'une fonction libre, un object foncteur avec une instance de C.

Code:

---

1 2 3 4 5 6 7

class Foncteur { C const& _instance; public: Foncteur(C const& c) : _instance(c) {} double operator()(double d) { return c.f(d); } };

---

Ça n'a pas déjà été proposé ? je m'emmêle ...

Si, je l'ai fait, mais j'avais bêtement appelé l'opérateur fonction au lieu de operator()Du coup, ca marchait moins bien ...

Je comprends l'idée du foncteur, mais je vois pas comment l'appliquer dans mon cas.

Il faudrait que au lieu d'avoir un fichier de fonctions libres, je devrais en faire une classe où je surcharge l'operateur () comment indiqué plus haut?

Citation:

---

Envoyé par LinuxUser

Il faudrait que au lieu d'avoir un fichier de fonctions libres, je devrais en faire une classe où je surcharge l'operateur () comment indiqué plus haut?

---

Regarde mon exemple au dessus, la magie s'opère sur la fonction "integration" qui permet d'utiliser en paramètre soit des fonctions libres, soit des bind, soit des lambda, soit des foncteurs,... La fonction d'intégration s'en moque : Il suffit que la fonction à intégrer s'appelle sous la forme double y = f(x).

Pour t'adapter à ça avec des méthodes sur des classes, tu te retrouves à passer d'un appel sous la forme c.fonction(x); à un appel sous la forme f(x). Pour ça, si tu ne veux pas faire des wrappers à la main sous forme de foncteur (chose assez pénible), il y a deux solutions propres illustrées par Ehonn : std::bind (après C++11), boost::bind (avant C++11).

Cette notion de bind est d'ailleurs omniprésente quand tu lis des documentations sur les threads à la sauce boost ou C++11 : Tu gagneras plus à te mettre à ça qu'en magouillant des pointeurs de fonction "C-like"...

Je suis malheureusement contraint à resté en C++98 standard et sans possiblité d'utiliser de lib externe (donc pas de boost).

Du coup, l'idée du wrapper C-like (qui a été suggéré deux fois) consiste en quoi exactement?

A avoir d'un côté une fonction qui prend une fonction en paramètre (de type void * func(double)) et de l'autre un wrapper qui convertir une méthode membre de type void C::func(double) en void *func(double) ?

Citation:

---

Envoyé par LinuxUser

Je suis malheureusement contraint à resté en C++98 standard et sans possiblité d'utiliser de lib externe (donc pas de boost).

---

Regarde mon exemple (message #11) avec std::bind1st et std::mem_fun, ce n'est que du C++98 ;)

Franchement je commence à avoir des doutes sur tes recherches. Voire sur la lecture des messages parfois.

Un foncteur, ça n'a rien de magique, et on en écrit depuis très longtemps. Inutile d'avoir du C++11 14 ou plus pour en écrire un. :weird:
Cas simple pour un foncteur qui ne prend pas de paramètre. A la louche de mémoire ça donne

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

struct Callback { virtual ~Callback() {} virtual void Call()=0; virtual void operator()()=0; }; struct FreeCallback : Callback { typedef void(*func)(); FreeCallback(func _func) : ptr(_func) {} void Call() { (*ptr)(); } void operator()() { (*ptr)(); } private: func ptr; }; template< class T > struct MemberCallback : Callback { typedef void(T::*ptrFct)(void); MemberCallback(T* object, ptrFct method) : m_obj(object), m_method(method) {} void Call() { m_obj->m_method(); } void operator()(void) { m_obj->m_method(); }   private: T* m_obj; ptrFct m_method; };

---

La seule chose qui est (beaucoup) mieux avec le code plus récent, c'est que les template permettent de factoriser l'écriture et te font les copier coller à ta place selon le type de retour, de chaque paramètre, du nombre de paramètre, ....
Là tu dois le faire toi-même.