Discussion :

[3DArchi]

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]

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

[3DArchi]

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]

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]

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]

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