type de retour de std::bind

Version imprimable

01/11/2010, 12h06
NoIdea

type de retour de std::bind
Bonjour à tous, suite à la lecture de ceci

Citation:

Evite comme la peste les membres et structures dont le noms est préfixé par l'underscore " _ " (ou le double underscore " __ " ).

Il s'agit de termes propres à l'implémentation que tu utilise, et il n'est pas du tout impossible qu'ils n'existent simplement pas si tu vient à changer de compilateur, voire, simplement, de version de la bibliothèque que tu utilise.

J'ai donc un petit problème avec std::bind. J'utilise des choses réservées à l'implémentation pour déterminer le type de retour de std::bind.
Voici le code :
Code:

1 2 3 typedef std::_Maybe_wrap_member_pointer<Fc> __maybe_type; typedef typename __maybe_type::type __functor_type; typedef std::_Bind<__functor_type(Args...)> ResultFunctorType;
Avec ResultFunctorType le type de retour.
Comment puis-je avoir ce type de manière portable ?
J'ai trouvé ce code dans functional de gcc4.5 Mingw après une recherche google non fructueuse.

Merci à tous.
01/11/2010, 12h45
Invité

Tu peux utiliser auto(ou decltype) si ce n'est que pour avoir le type lors de l'appel à bind. Sinon il faut regarder du coté de std::function<>(ou boost::function<>, ou autres du meme genre)
01/11/2010, 13h17
Joel F

+1 pour auto ici
01/11/2010, 13h43
NoIdea

J'utilise déjà auto, mais je dois ensuite repasser cette objet dans une classe template et donc lui donner le type de l'objet.

Quelque chose comme ceci ne te convient pas ?

Code:

1
2
3
4
 
auto maFonctionBindee = bind(maFonction, _1, 3);
MaClasse<decltype(maFonctionBinde)> linstanceDeMaClasse;
linstanceDeMaClasse.passerLaFonctionBindee(maFonctionBinde);

01/11/2010, 15h34
NoIdea

Je dois dire que je ne dois pas comprendre comment decltype marche... mais je vais tester. Quelqu'un aurait un lien expliquant decltype ?

En fait, sa marche pas :

J'ai une fonction appelant std::bind avec un tuple. La fonction va extraire le tuple et le passer à std::bind. Sauf que je dois mettre son type de retour que ne connait pas. Voici le code :
Code:

1 2 3 4 5 6 7 8 9 template<typename Fc,typename ...Args> struct Binding { typedef std::_Maybe_wrap_member_pointer<Fc> __maybe_type; typedef typename __maybe_type::type __functor_type; typedef std::_Bind<__functor_type(Args...)> ResultFunctorType; inline static ResultFunctorType MakeBindingObject(Fc Func, const std::tuple<Args...>& t); };
Quelle solution proposez vous ?

01/11/2010, 16h53
Invité
Je proposerais la plus simples meme si ce n'est pas la plus efficace, utiliser std::function<>.
En fait je viens de me rapeller d'une utilisation légèrement spéciale de auto que je crois tu peux appliquer ici:
Code:

1 2 3 template<class U, class V> auto maFonction(U const& u, V const& v) -> decltype(u+v);
Je verrais ça avec une fonction publique et deux privé qui **itèrent** sur le tuple.
01/11/2010, 17h16
NoIdea

Avec gcc, j'obtiens une erreur si je déclare MakeBindingObject comme
auto MakeBindingObject(/*...*/)

Voici l'erreur :

error: 'MakeBindingObject' function uses 'auto' type specifier without late return type

Oui, ca ne marche pas comme ca, il faut utiliser la syntaxe donné par Joe Dralliam :
Code:

1 2 3 4 5 6 7 8 template<typename Fc,typename ...Args> struct Binding { static auto MakeBindingObject(Fc Func, const std::tuple<Args...>& t) ->decltype(std::bind(Func,std::get<0>(t))) { return std::bind(Func,std::get<0>(t)); } };
Par exemple (on peut utiliser [] à la place de auto aussi).

(cf FaQ de Bjarne pour tout ce qui concerne auto et decltype)

Bon je vais chercher pour auto et decltype, cependant, je ne vois pas comment faire sa dans mon cas.
Je vous montre le code un peu plus complet :

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
namespace
{
    template<unsigned int N, typename Fc, typename R, typename ...Args>
    struct ExtractTuple
    {
        template<typename ...Finis>
        inline static R Extract(Fc Func, const std::tuple<Args...>& t, Finis...Extracted)
        {
            return ExtractTuple<N-1, Fc, R, Args...>::Extract
            (static_cast<Fc>(Func), t, std::get<N-1>(t), Extracted...);
        }
    };
 
    template<typename Fc, typename R,  typename ...Args>
    struct ExtractTuple<0u, Fc,R,  Args...>
    {
        template<typename ...Finis>
        inline static R Extract(Fc Func, const std::tuple<Args...>&, Finis... Extracted)
        {
            return std::bind(Func, Extracted...);
        }
    };
 
    template<unsigned int N, typename R,typename Fc>
    struct ExtractFirst
    {
        template<typename ...Args>
        inline static R Extract(Fc Func, const std::tuple<Args...>& t)
        {
            return ExtractTuple<N-1, Fc, R,Args...>::Extract
            (static_cast<Fc>(Func), t, std::get<N-1>(t));
        }
    };
 
    template<typename R,typename Fc>
    struct ExtractFirst<0,R,Fc>
    {
        template<typename ...Args>
        inline static R Extract(Fc Func, const std::tuple<Args...>& )
        {
            return std::bind(Func);
        }
    };
}
template<typename Fc,typename ...Args>
inline typename sf::GUI::Implementation::Binding<Fc,Args...>::ResultFunctorType sf::GUI::Implementation::Binding<Fc,Args...>::MakeBindingObject(Fc Func, const std::tuple<Args...>& t)
{
    return ExtractFirst<sizeof...(Args), ResultFunctorType,Fc>::Extract(static_cast<Fc>(Func), t);
}

Si quelqu'un a une idée ...

Ave ce code c'est très simple :

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
 
 
namespace
{
    template<unsigned int N, typename Fc, typename ...Args>
    struct ExtractTuple
    {
        template<typename ...Finis>
        inline static auto Extract(Fc Func, const std::tuple<Args...>& t, Finis...Extracted) -> decltype(ExtractTuple<N-1, Fc, Args...>::Extract       (static_cast<Fc>(Func), t, std::get<N-1>(t), Extracted...))
        {
            return ExtractTuple<N-1, Fc, Args...>::Extract
            (static_cast<Fc>(Func), t, std::get<N-1>(t), Extracted...);
        }
    };
 
    template<typename Fc,  typename ...Args>
    struct ExtractTuple<0u, Fc,  Args...>
    {
        template<typename ...Finis>
        inline static auto Extract(Fc Func, const std::tuple<Args...>&, Finis... Extracted) -> decltype(std::bind(Func, Extracted...))
        {
            return std::bind(Func, Extracted...);
        }
    };
 
    template<unsigned int N,typename Fc>
    struct ExtractFirst
    {
        template<typename ...Args>
        inline static auto Extract(Fc Func, const std::tuple<Args...>& t) -> decltype(ExtractTuple<N-1, Fc,Args...>::Extract(static_cast<Fc>(Func), t, std::get<N-1>(t)))
        {
            return ExtractTuple<N-1, Fc,Args...>::Extract(static_cast<Fc>(Func), t, std::get<N-1>(t));
        }
    };
 
    template<typename Fc>
    struct ExtractFirst<0,Fc>
    {
        template<typename ...Args>
        inline static auto Extract(Fc Func, const std::tuple<Args...>& ) -> decltype(std::bind(Func))
        {
            return std::bind(Func);
        }
    };
}
 
 
template<typename Fc,typename ...Args>
inline auto sf::GUI::Implementation::Binding<Fc,Args...>::MakeBindingObject(Fc Func, const std::tuple<Args...>& t) -> decltype(ExtractFirst<sizeof...(Args),Fc>::Extract(static_cast<Fc>(Func), t))
{
    return ExtractFirst<sizeof...(Args),Fc>::Extract(static_cast<Fc>(Func), t);
}

Pour cette utilisation d'auto tu peux aller voir par ici

NB : Le code n'est pas testé, il peut manquer des parenthèses,point-virgule etc...

01/11/2010, 18h34
NoIdea

Il faut donc mettre des auto partout... ok merci je test tout de suite.
01/11/2010, 18h42
NoIdea

En tout cas, petit problème :

Comme vous voyez, j'utilise un espace de nom anonyme dans mon .inl
Ceci cause comme problèmes que mon .hpp n'a aucune connaissance des classes ExtractFirst et autres.
Cependant, il semblerait que je sois obligé de mettre le ->decltype() aussi dans le header (à moins que sa ne soit que dans le header). Comment faire ?
01/11/2010, 18h55
NoIdea

J'ai sortit tout sa du namespace anonyme, et j'obtiens plein de sorry,unimplemented avec gcc4.5
01/11/2010, 21h59
Flob90

J'ai l'impression que GCC n'implement pas encore totalement bind, pas correctement du moins. Essay avec quelque chose comme bind1st à la place. Du coup plus de probème de retour car le type de retour de bind1st est bien définie.
01/11/2010, 22h08
NoIdea

Je ne doute pas que sa marche avec bind1st, malheuresement, j'ai besoin de bind... il y a un autre moyen que auto et decltype pour faire ce que je veux ?
01/11/2010, 22h17
Flob90
Faut que tu changes de compilateur alors. Le problème ne vient pas de auto et decltype mais de bind, si tu veus en avoir le coeur net, tests :
Code:

1 2 3 4 5 6 int foo(int,int){return 0;} std::function<int (int, int)> f(&foo); auto f2 = std::bind(f,0); f2(0);
Qui si je ne me trompe pas sur la lecture du draft devrait compiler sans problème (et compile avec bind1st), ne compile pas avec gcc.
01/11/2010, 22h19
NoIdea

Je vais tester. Gcc 4.6 corrige ce bug ?
02/11/2010, 10h26
Invité

Le problème ne vient pas std::bind(les memes erreurs apparaissent avec boost::bind) mais du mélange decltype/template variadiques....
Et gcc 4.6 ne corrige pas le bug, malheureusement
02/11/2010, 14h25
NoIdea

Y a t-il un moyen de faire ceci sans passer par decltype ?
Est-ce que le type du foncteur renvoyé par std::bind est définit dans la norme ?
Si oui, j'ai juste à regarder à quoi ces typedefs correspondent et essayer de passer outre.
02/11/2010, 15h39
NoIdea

Bon, j'ai tenter de ruser mais sans grand succès. Après avoir lu plus précisément le header functional, je me suis rendu compte que les 2 premiers typedefs ne servaient à rien dans mon cas.
Donc pour simplifier, j'ai ceci :

Code:

typedef std::_Bind<Fc(Args...)> ResultFunctorType;

j'ai malheureusement toujours un _ , j'ai donc voulus utiliser std::result_of.

Code:

typedef typename std::result_of<(decltype(std::bind<Fc,Args...>))(Fc, Args...)>::type R;

Malheureusement, j'obtiens l'erreur suivante :

error: a comma operator cannot appear in a constant-expression|

Est-ce un bug ou est-ce normal ?
Quelqu'un a une idée ?

Le type de retour de bind n'est pas définie.

@Joe Dralliam: Je crois que le bind du dernier draft n'est pas le même que celui de boost, et ce code :
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<cstdlib> #include<cstddef> #include<functional> #include<tuple> #include<iostream> template<class Fc, class ...Arg> auto bind_tuple_first(Fc f, const std::tuple<Arg...>& t) -> decltype(std::bind(f, std::get<0>(t) )) { return std::bind(f, std::get<0>(t) ); } void foo(int,int){std::cout << 0;} int main () { std::function<void (int,int)> f(foo); std::tuple<int> t(0); auto f2 = bind_tuple_first(f,t); f2(0); system("PAUSE"); return EXIT_SUCCESS; }
Ne compile pas, mais compile si tu ne mets q'un seul argument à foo, compile avec bind1st et l'erreur est la même que le code que j'ai mis plus haut qui n'utilise pas de decltype et autre (un auto mais on peut l'écrire sans).

Et il me semble bien que si la fonction prend deux arguments, qu'on fait un bind(f,0), alors le retour est un wrapper sur quelque chose qu'on peut utiliser comme ca f2(0), et qui doit appeller f(0,0).

03/11/2010, 12h08
NoIdea

Citation:

Le type de retour de bind n'est pas définie.

Comment est-ce possible ? De plus, mon typedef ResultFonctorType est bel et bien le type de retour de std::bind.
03/11/2010, 12h45
Flob90

Bha, c'est possible car c'est écrit dans le draft :

Citation:

template<class F, class... BoundArgs>
unspecified bind(F&& f, BoundArgs&&... bound_args);

C'est donc à celui qui code la STL de faire comme il veut, dans ton cas ils ont appelé le type qui représente le wrapper _Bind<Fc(Arg...)>.

Sans en être certain, je dirais que ce genre de chose va de pair avec l'introduction de auto decltype et des lambda qui permettent de moins s'attacher au type et plus aux opérations effectué.
03/11/2010, 13h12
NoIdea

Citation:

C'est donc à celui qui code la STL de faire comme il veut, dans ton cas ils ont appelé le type qui représente le wrapper _Bind<Fc(Arg...)>.

Ok merci de cette réponse. Je croyais que tu voulais dire que bind n'avais pas de type réel. En fait tu veux dire qu'il dépend de l'implémentation. Cependant, cela n'explique pas pourquoi std::result_of ne marche pas.

Citation:

Sans en être certain, je dirais que ce genre de chose va de pair avec l'introduction de auto decltype et des lambda qui permettent de moins s'attacher au type et plus aux opérations effectué.

En effet.
03/11/2010, 14h14
Flob90
decltype ne passe pas sur bind<>, car il n'arrive pas à déterminer le type de la fonction car il existe plusieurs versions.

Mais si à la place d'utiliser result_of tu passes directement par decltype sur un appel à bind ca marche :
Code:

1 2 typedef decltype(std::bind(F(),Arg()...)) R;
Mais ca revient en gros à utiliser auto et -> decltype, comme on l'a fait au début du thread, c'est juste plus verbeux (et je suis presque certain que le code ne marchera pas mieux ...)
03/11/2010, 14h15
NoIdea

Oui, mais la chose du début ne compile pas avec gcc4.5, je vais voir si celle la compile.
03/11/2010, 14h22
NoIdea

Code:

typedef decltype(std::bind(Fc(),Args()...)) R;

ne marche pas : le compilateur me dit qu'il ne peut appelé Fc sans paramètres.
J'ai tout de même une question, à quoi servent les parenthèses après Args ?
Pourquoi le compilateur n'accepte-il pas quand je met Fc sans les parenthèses ?
(error=function returning a function).
03/11/2010, 14h54
Flob90
Code:

1 2 3 4 5 6 template<class Fc, class ...Arg> struct bind_trait { typedef decltype(std::bind(Fc(),Arg()...)) Type; };
Compile sans problème chez moi.

Si je me trompe pas Arg()... c'est comme Fc() (une instanciation), mais pour une liste d'argument, donc avec int,int, ca va faire 0,0 (si il y a zero-initialisation, chose dont je ne suis pas certain).
03/11/2010, 14h56
NoIdea

Il faut donc un constructeur par défaut ? Ou je n'ai rien compris...

Avec cette technique oui, mais je crois que pour un premier jet tu peus te restreindre à des chose DefaultConstrcutible, tu verras après pour adapter.

Je serrais partie sur un truc comme ca :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 template<size_t N> struct Help { template<class F, class ...Arg> auto Do(F&& f, const std::tuple<Arg...>& t) -> decltype(Help<N-1>::Do(std::bind(f, std::get<(sizeof...(Arg))-N>(t)),t)) { return Help<N-1>::Do(std::bind(f, std::get<(sizeof...(Arg))-N>(t)),t); } }; template<> struct Help<0> { template<class F, class ...Arg> auto Do(F&& f, const std::tuple<Arg...>&) -> decltype(std::bind(f)) { return std::bind(f); } }; template<class F, class ...Arg> auto make(F&& f, const std::tuple<Arg...>& t) -> decltype(Help<sizeof...(Arg)>::Do(f, t)) { return Help<sizeof...(Arg)>::Do(f, t); }
Ca compile, mais ca ne marche pas lors de l'utilisation, je dois oublier un détail sur les templates qui fait que ca marche pas. (et de toute manière ca ne marchera pas dans toute les situations à cause de bind AMHA)

03/11/2010, 15h17
NoIdea

Mes objets ne sont pas default constructible, et j'ai déjà une méthode qui marche (ce qui me permet d'avancer tout de même). J'attendrais donc une version de gcc ou decltype et auto marcheront biens ou bien que quelqu'un trouve une autre solution...
03/11/2010, 15h20
Flob90

Citation:

Envoyé par NoIdea

Mes objets ne sont pas default constructible, et j'ai déjà une méthode qui marche (ce qui me permet d'avancer tout de même). J'attendrais donc une version de gcc ou decltype et auto marcheront biens ou bien que quelqu'un trouve une autre solution...

Tu pourrais poster ta solution stp ? J'aimerais tester :)
03/11/2010, 15h40
NoIdea

Code:

typedef std::_Bind<Fc(Args...)> ResultFunctorType;

Avec gcc4.5, sa marche parfaitement. Mais j'utilise toujours quelque chose de réserver à l'implémentation.
04/11/2010, 19h47
deubelte

Puisqu'on est sur la fonction bind, je voudrais savoir ce que renvoie la ligne de code:

Code:

bind(less<int>(),9);

j'arrive pas à trouver.

Merci
05/11/2010, 01h23
Flob90

On l'a écrit plus haut : le type de retour de bind n'est pas spécifie, donc il faut utiliser auto. (où alors un typedef définit par ton compilateur qui représente le type de retour comme le fait NoIdea, mais ce 'nest pas portable).

NB: Et les codes que j'ai posté avant (les premiers), ne compilait pas car j'avais oublié d'utiliser les placeholders, avec eux ca compile (je croyais qu'ils n'était pas obligatoire mais apparament si).
05/11/2010, 09h13
deubelte

Je suis d'accord avec l'utilisation d'auto, c'est ce que j'ai fait.

Disons que je n'arrive pas à comprendre pourquoi cela compile:

Code:

transform(V1.begin(),V1.end(),V1.begin(),bind(plus<int>(),3,(bind(less<int>(),5),_1)));

Comme on le voit, on utilise bind avec plus<int>(), 3 ce qui est normal, mais aussia avec (bind(less<int>(),5),_1). Je m'étonne que cela compile car bind(less<int>(),5) ne signifie rien.
05/11/2010, 19h11
Flob90

Ca applique l'algo transform à ta séquence avec le "functeur" (ca à un autre nom dans la norme, mais je trouve celui très clair), qui s'applique sur un paramètre n et qui retourne 3 + n.

Il y a utilisation de l'opérateur , (qui permet d'appeller l'expression à gauxche avant celle de droite puis de retourner celle de droite). Mais ici j'ai l'impression qu'il ne sert à rien, c'est équivalent à :
transform(V1.begin(),V1.end(),V1.begin(),bind(plus<int>(),3,_1));

J'ai une idée pour ton problème.

Comme l'a dit Joe Dralliam, le problème vient de l'utilisation de decltype avec les template variadique.

Mais ceci :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 template<size_t N> struct Make { template<class F, class ...Arg, class ...Extracted> static auto Do(F f, const std::tuple<Arg...>& t, Extracted... arg) -> decltype(std::bind(f,Arg()...)) { return Make<N-1>::Do(f, t, std::get<N-1>(t), arg...); } }; template<> struct Make<0> { template<class F, class ...Arg, class ...Extracted> static auto Do(F f,const std::tuple<Arg...>& , Extracted... arg) -> decltype(std::bind(f,Arg()...)) { return std::bind(f,arg...); } };
Fonctionne bien pour les type DefaultConstructible (si on met ce qu'il y a après le retourne après le decltype ca ne marche plus, il ne supporte pas quelque chose à propos des variadics).

Et si tu veus utiliser un fonction qui prend en paramètre des chose non constructible, en créant un nouveau foncteur à partir du premier qui transforme les paramètre non constructible en pointeur, ca devrait marcher :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 template<class ...Arg> struct New { template<class F> struct Functor { F f; Functor(F p) : f(p) {} void operator()(Arg* ...arg) { f(*arg...); } }; template<class F> static Functor<F> Do(F f) { return Functor<F>(f); } };
Quelque chose comme ca (à améliorer et à vérifier si ca n'existe pas déja).

Et ensuite il faut tranformer le tuples de la même manière : faire un tuple d'addresse sur les objet du premier tuple.

Et je n'ai pas essayer, mais on peut surment faire bien mieux en ne tranformant que ceux qui ne sont pas constructible et en remplacant les non-constructible par des default constructible qui peuvent aussi être construit à partir des premiers. Je pense que ca permettrait d'utiliser directement le tuple.

Un exemple "complet" (fait à la va-vite, fuite mémoire)
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 struct A { A(int){} }; void foo(A,int,int){ std::cout << 0; } template<size_t N> struct Make { template<class F, class ...Arg, class ...Extracted> static auto Do(F f, const std::tuple<Arg...>& t, Extracted... arg) -> decltype(std::bind(f,Arg()...)) { return Make<N-1>::Do(f, t, std::get<N-1>(t), arg...); } }; template<> struct Make<0> { template<class F, class ...Arg, class ...Extracted> static auto Do(F f,const std::tuple<Arg...>& , Extracted... arg) -> decltype(std::bind(f,Arg()...)) { return std::bind(f,arg...); } }; template<class ...Arg> struct New { template<class F> struct Functor { F f; Functor(F p) : f(p) {} void operator()(Arg* ...arg) { f(*arg...); } }; template<class F> static Functor<F> Do(F f) { return Functor<F>(f); } }; int main () { std::tuple<A*,int*,decltype(std::placeholders::_1)> t(new A(0),new int(),std::placeholders::_1); auto f1 = New<A,int,int>::Do(foo); auto f2 = Make<3>::Do(f1, t); f2(new int()); system("PAUSE"); return EXIT_SUCCESS; }