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

**3DArchi** · 03/03/2009, 17h56

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

Code :

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

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 :

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

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.

**HanLee** · 03/03/2009, 19h48

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

**3DArchi** · 04/03/2009, 11h27

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 :

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

make_boost_function(&MaClasse::MaMethode);

Et non pas :

Code :

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

1
2
 
boost::function<void (MaClasse*,int,int)> fonction = &MaClasse::MaMethode;

**Mat007** · 04/03/2009, 13h31

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.

**Nogane** · 04/03/2009, 13h35

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 :

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

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

**3DArchi** · 04/03/2009, 14h10

Au temps pour moi, je me suis mal exprimé sur mon besoin

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 :

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

@Nogane : chez moi, ça ne compile pas :

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

**Nogane** · 04/03/2009, 14h26

En effet, j'aurai du tester sur des cas plus subtil.
La solution que j'aurai utiliser dans ton cas est le bind:

Code :

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

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 :

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

1
2
 
  invoquer_un_a(A(),boost::function<void (A*,int,int)>(&A::MaMethode));

Mais c'est vrai que c'est pas encore parfait.

**3DArchi** · 04/03/2009, 14h32

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

...

**Matthieu Brucher** · 04/03/2009, 14h51

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.

**3DArchi** · 04/03/2009, 16h11

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 :

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

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

**3DArchi** · 05/03/2009, 12h17

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

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

**JolyLoic** · 05/03/2009, 19h16

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

**loufoque** · 06/03/2009, 00h42

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.

**3DArchi** · 06/03/2009, 08h20

Envoyé par JolyLoic

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

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.

**loufoque** · 06/03/2009, 17h25

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 :

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