[Boost function] Existe-t-il un make.

Version imprimable

Bonjour,
J'ai farfouillé dans Boost.Function sans succès. Je cherche quelque chose qui ferait ça :
Code:

1 2 3 4 5 6 7 8 template<class T,class R, class Arg1, class Arg2> boost::function3<R, T*,Arg1,Arg2> make_boost_function(R (T::*t)(Arg1,Arg2)) { boost::function3<R, T*,Arg1,Arg2> func; func = t; return func; };
Bien sûr, pour function0, function1, ..., functionN.
L'avantage est de pouvoir faire ensuite :
Code:

1 2 make_boost_function(&MaClasse::MaMethode);
[EDIT] : je pourrais retomber sur mes pattes en passant par bind plutôt que directement par boost::function, mais ce n'est pas la solution que je cherche.

03/03/2009, 19h48
HanLee

Si ta signature est déjà bonne, il n'y a aucun problème : c'est convertible directement en boost::function<>.
04/03/2009, 11h27
3DArchi
Citation:

Envoyé par HanLee

Si ta signature est déjà bonne, il n'y a aucun problème : c'est convertible directement en boost::function<>.

Salut,
Je comprend pas ce que tu veux dire.
Je souhaite pouvoir faire des choses comme ça :

Code:

make_boost_function(&MaClasse::MaMethode);

Et non pas :
Code:

1 2 boost::function<void (MaClasse*,int,int)> fonction = &MaClasse::MaMethode;
04/03/2009, 13h31
Mat007

Salut,

Je pense qu'il voulait dire qu'en l'état make_boost_function ne sert à rien puisqu'il suffit de passer directement le pointeur sur fonction là où tu voudrais passer le retour de make_boost_function (par ex pour l'affecter à un boost::function ou en paramètre d'une fonction prenant un boost::function).

Il faudrait que tu détailles un peu plus comment tu comptes exploiter ce que te retournerait ce make_boost_function et pourquoi utiliser un boost::function directement ne convient pas.

MAT.
04/03/2009, 13h35
Nogane
Bonjours,
Je ne vois pas vraiment l'intérêt d'un make_boost_function non plus.
Mais si l'intérêt existe voila un code que je vient de tester sur des cas simple:
Code:

1 2 3 4 5 template<class T> function<T> make_boost_function(const T &func) { return function<T>(func); }
Si ça sert vraiment a rien, ben tampi ^^

Au temps pour moi, je me suis mal exprimé sur mon besoin :marteau:
L'idée est tout simplement de me faciliter la vie.
Au lieu d'écrire, à chaque fois boost::function<patati_et_patata> fonction = trucmuche, je voulais savoir s'il existait une fonction du genre make_boost_function qui ferait le boulot pour moi. Certaines bibliothèques boost ont des fonctions de ce type qui permettent de retourner le bon objet en le déduisant des paramètres de la fonction (par exemple, boost::in_place te retourne la bonne instance de boost::in_place_factoryN dans Boost.In Place Factory, ou encore les fonctions suffixées en _p dans Boost.Spirit qui retourne l'objet adéquat). Cela simplifie grandement l'écriture en général.
Donc ma question est : est-ce que je dois me palucher à la main des make_boost_function pour un nombre d'argument variant de 0 à n, ou est-ce que ceci existe déjà.
Un 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 26 27 28 29 30 #include <iostream> #include <boost/function.hpp> class A { public: void MaMethode(int,int){std::cout<<"coucou"<<std::endl;} }; template<class T> void invoquer_un_a(A a,T t_) { t_(&a,1,1); } template<class T,class R, class Arg1, class Arg2> boost::function3<R, T*,Arg1,Arg2> make_boost_function(R (T::*t)(Arg1,Arg2)) { boost::function3<R, T*,Arg1,Arg2> func; func = t; return func; }; int main() { invoquer_un_a(A(),make_boost_function(&A::MaMethode)); // au lieu de : invoquer_un_a(A(),boost::function<void (A*,int,int)>(&A::MaMethode)); return 0; }
[EDIT] : les seuls avantages sont de ne pas avoir à écrire la signature de ma fonction à chaque fois (ma mémoire est faible), de ne pas avoir à réécrire si jamais cette signature change, et je trouve un peu plus lisible (question de point de vue, j'en convient). Sinon, utiliser explicitement boost::function ne pose pas de problème. Je souhaite simplement me simplifier la vie :mrgreen:
@Nogane : chez moi, ça ne compile pas :
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 #include <iostream> #include <boost/function.hpp> class A { public: void MaMethode(int,int){std::cout<<"coucou"<<std::endl;} }; template<class T> void invoquer_un_a(A a,T t_) { t_(&a,1,1); } template<class T> boost::function<T> make_boost_function(const T &func) { return boost::function<T>(func); } int main() { invoquer_un_a(A(),make_boost_function(&A::MaMethode)); // au lieu de : invoquer_un_a(A(),boost::function<void (A*,int,int)>(&A::MaMethode)); return 0; }

04/03/2009, 14h26
Nogane
En effet, j'aurai du tester sur des cas plus subtil.
La solution que j'aurai utiliser dans ton cas est le bind:
Code:

1 2 invoquer_un_a(A(), boost::bind(&A::MaMethode, _1, _2, _3));
Ça marche, et c'est toujours plus pratique(a mon humble avis) que :
Code:

1 2 invoquer_un_a(A(),boost::function<void (A*,int,int)>(&A::MaMethode));
Mais c'est vrai que c'est pas encore parfait.
04/03/2009, 14h32
3DArchi

Citation:

Envoyé par Nogane

La solution que j'aurai utiliser dans ton cas est le bind

C'est ce que j'avais marqué dans mon premier post : on peut toujours s'en sortir avec bind comme tu le fais. Mais ça nécessite encore de spécifier le bon nombre d'arguments. Peut être que ma question n'a pas d'intérêt donc pas de réponse :(...
04/03/2009, 14h51
Matthieu Brucher

Citation:

Envoyé par 3DArchi

Certaines bibliothèques boost ont des fonctions de ce type qui permettent de retourner le bon objet en le déduisant des paramètres de la fonction (par exemple, boost::in_place te retourne la bonne instance de boost::in_place_factoryN dans Boost.In Place Factory, ou encore les fonctions suffixées en _p dans Boost.Spirit qui retourne l'objet adéquat).

En fait, c'est du C++ classique. std::make_pair est un exemple. Ca marche sur les fonctions, mais pas sur les classes. Donc si tu as besoin d'indiquer un type, tu ne peux pas t'en passer.
Dans ton cas, tu dois indiquer le type à un moment pour que ta fonction soit instancier avec le bon, donc pas trop le choix.

Citation:

Envoyé par Matthieu Brucher

En fait, c'est du C++ classique. std::make_pair est un exemple. Ca marche sur les fonctions, mais pas sur les classes. Donc si tu as besoin d'indiquer un type, tu ne peux pas t'en passer.
Dans ton cas, tu dois indiquer le type à un moment pour que ta fonction soit instancier avec le bon, donc pas trop le choix.

On est tout à fait d'accord. C'est pour ça qu'on trouve des fonctions qui se contentent de créer un objet. Ca permet de créer l'objet sans avoir à écrire son type, celui-ci est 'deviné' par la fonction.

Bon, donc j'ai fait ça :

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 <boost/function.hpp>
#include <boost/preprocessor/iteration/local.hpp>
#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/repetition/enum_trailing_params.hpp>
 
#define MAKE_BOOST_FUNCTION_FREE(n)\
   template<class R BOOST_PP_ENUM_TRAILING_PARAMS(n,class Arg)>\
   boost::BOOST_PP_CAT(function,n)<R BOOST_PP_ENUM_TRAILING_PARAMS(n,Arg)> make_boost_function(R (*func)(BOOST_PP_ENUM_PARAMS(n,Arg)))\
   {\
      return boost::BOOST_PP_CAT(function,n)<R BOOST_PP_ENUM_TRAILING_PARAMS(n,Arg)>(func);\
   }
 
#define MAKE_BOOST_FUNCTION_MEMBER(n)\
   template<class R,class T BOOST_PP_ENUM_TRAILING_PARAMS(n,class Arg)>\
   boost::BOOST_PP_CAT(function,BOOST_PP_INC(n))<R, T* BOOST_PP_ENUM_TRAILING_PARAMS(n,Arg)> make_boost_function(R (T::*mbr)(BOOST_PP_ENUM_PARAMS(n,Arg)))\
   {\
      return boost::BOOST_PP_CAT(function,BOOST_PP_INC(n))<R, T* BOOST_PP_ENUM_TRAILING_PARAMS(n,Arg)>(mbr);\
   }
 
#define MAKE_BOOST_FUNCTION_MEMBER_CONST(n)\
   template<class R,class T BOOST_PP_ENUM_TRAILING_PARAMS(n,class Arg)>\
   boost::BOOST_PP_CAT(function,BOOST_PP_INC(n))<R, const T* BOOST_PP_ENUM_TRAILING_PARAMS(n,Arg)> make_boost_function(R (T::*mbr)(BOOST_PP_ENUM_PARAMS(n,Arg))const )\
   {\
      return boost::BOOST_PP_CAT(function,BOOST_PP_INC(n))<R, const T* BOOST_PP_ENUM_TRAILING_PARAMS(n,Arg)>(mbr);\
   }
 
#define MAKE_BOOST_FUNCTION(unused_,n,unused2_)\
   MAKE_BOOST_FUNCTION_FREE(n)\
   MAKE_BOOST_FUNCTION_MEMBER(n)\
   MAKE_BOOST_FUNCTION_MEMBER_CONST(n)
 
 
#define BOOST_PP_LOCAL_MACRO(n)   MAKE_BOOST_FUNCTION(~, n, ~)
#define BOOST_PP_LOCAL_LIMITS     (0, BOOST_FUNCTION_MAX_ARGS-1)
#include BOOST_PP_LOCAL_ITERATE()
// le dernier uniquement pour les fonctions libres:
MAKE_BOOST_FUNCTION_FREE(BOOST_FUNCTION_MAX_ARGS)

J'aurais aimé éviter le faire et qu'une telle fonction existe déjà dans boost.

[EDIT]
Ce qui me génère ça pour n=0 à 10 :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
template<class R , class Arg0 , class Arg1 , class Arg2 , class Arg3 , class Arg4, ..., class Argn> 
boost::functionN<R , Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , ...,Argn> 
make_boost_function(R (*func)( Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , ...,Argn)) 
{ 
   return boost::functionN<R , Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , ...,Argn>(func); 
} 
 
template<class R,class T , class Arg0 , class Arg1 , class Arg2 , class Arg3 , class Arg4, ..., class Argn-1> 
boost::functionN+1<R, T* , Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , ...,Argn-1> 
make_boost_function(R (T::*mbr)( Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , ...,Argn-1)) 
{ 
   return boost::functionN+1<R, T* , Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , ...,Argn-1>(mbr); 
} 
 
template<class R,class T , class Arg0 , class Arg1 , class Arg2 , class Arg3 , class Arg4, ..., class Argn-1> 
boost::functionN+1<R, const T* , Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , ...,Argn-1> 
make_boost_function(R (T::*mbr)( Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , ...,Argn-1)const ) 
{ 
   return boost::functionN+1<R, const T* , Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , ...,Argn-1>(mbr); 
}

(vivement les variatic templates...).

En fait, j'ai trouvé quelque chose qui répond dans Boost.Membre Function : boost::mem_fn :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 #include <iostream> #include <boost/mem_fn.hpp> class A { public: void MaMethode(int,int){std::cout<<"coucou"<<std::endl;} }; template<class T> void invoquer_un_a(A a,T t_) { t_(&a,1,1); } int main() { invoquer_un_a(A(),boost::mem_fn(&A::MaMethode)); return 0; }
boost::mem_fn est ce que j'essayais d'obtenir avec mon make_boost_function pour Boost.Function...

Bien sûr, Boost.Member Function ne s'appuie pas du tout sur Boost.Function (ou inversement). Des fois, je me dis que Boost gagnerait à un grand nettoyage pour regrouper des choses de ce type qui sont redondantes ou presque (au minimum tout ça mériterait d'être regroupé).

05/03/2009, 19h16
JolyLoic

De mémoire, boost::function a un coût que boost::mem_func n'a pas.
06/03/2009, 00h42
loufoque

C'est fou cette incompréhension qu'il peut y avoir sur boost::function. C'est un système de type erasure pour les foncteurs (qui ne fonctionne cependant que pour une seule signature), rien d'autre. Ça n'a rien à voir avec boost::bind, par exemple, qui retourne un foncteur de type non spécifié, potentiellement polymorphique.

La raison pour laquelle un make_boost_function n'existe pas, c'est tout simplement parce qu'il n'est pas possible d'inférer une signature sur un foncteur, ceux-ci n'exposant en général pas cette information.

boost::mem_fun n'a aussi rien à voir, puisque ça convertit un pointeur vers une fonction membre en un foncteur qui va utiliser son premier argument comme objet et va forwarder les autres à la fonction membre.
06/03/2009, 08h20
3DArchi

Citation:

Envoyé par JolyLoic

De mémoire, boost::function a un coût que boost::mem_func n'a pas.

Citation:

Envoyé par loufoque

C'est fou cette incompréhension qu'il peut y avoir sur boost::function. C'est un système de type erasure pour les foncteurs (qui ne fonctionne cependant que pour une seule signature), rien d'autre.

Bonjour,
Je veux bien quelques détails d'explication car en brut comme ça, je ne comprend pas.
Merci.

Un foncteur ça peut avoir n'importe quel type.
boost::function est simplement est type qui peut contenir n'importe quel type de foncteur satisfaisant une certaine signature.
C'est un peu comme boost::any, en fait, sauf que boost::any ne nécessite aucune propriété sur les types qu'il peut contenir, alors que boost::function nécessite que ces types soient appelables avec une certaine signature.

Voici comment on peut implémenter function<R, T>, qui peut contenir tout foncteur appelable avec la signature R(T).

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
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
template<typename R, typename T>
struct function_impl_base
{
     virtual function_impl_base* clone() const = 0;
 
     virtual R operator()(T) const = 0;
     virtual R operator()(T) = 0;
};
 
template<typename R, typename T, typename F>
struct function_impl : function_impl_base<R, T>
{
     function_impl(const F& f_) : f (f_)
     {
     }
 
     function_impl_base<R, T> clone() const
     {
          return new function_impl<R, T, F>(*this);
     }
 
     R operator()(T t)
     {
         return f(t);
     }
 
     R operator()(T t) const
     {
          return f(t);
     }
 
private:
    F f;
};
 
template<typename R, typename T>
struct function
{
    template<typename F>
    function(const F& f) : p(new function_impl<T, R, F>(f))
    {
    }
 
    function(const function& f) : p(f.p->clone())
    {
    }
 
    template<typename F>
    function& operator=(const F& f)
    {
        function_impl_base<T, R>* tmp = new function_impl<T, R, F>(f);
        delete p;
        p = tmp;
    }
 
    function& operator=(const function& f)
    {
        function_impl_base<T, R>* tmp = f.p->clone();
        delete p;
        p = tmp;
    }
 
    ~function()
    {
        delete p;
    }
 
    R operator()(T t)
    {
        return (*p)(t);
    }
 
    R operator()(T t) const
    {
        return (*static_cast<const function_impl_base<T, R>*>(p))(t);
    }
 
private:
    function_impl_base<T, R>* p;
};

Tu comprends mieux ce que c'est maintenant ?

06/03/2009, 17h30
Alp

L'erasure provient je suppose du fait de faire disparaître le types sous-jacents lorsque l'on stocke dans un boost::function ?
06/03/2009, 17h47
loufoque

Oui, c'est le fait que tu effaces l'information que le type du foncteur est un certain F, et remplace ça par boost::function.