Discussion :

[NoIdea]

Bonjour � tous, suite � la lecture de ceci

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 :

S�lectionner tout - Visualiser dans une fen�tre � part

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.

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

[Joel F]

+1 pour auto ici

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

[Invit�]

Quelque chose comme ceci ne te convient pas ?

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

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

[NoIdea]

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

[NoIdea]

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 :

S�lectionner tout - Visualiser dans une fen�tre � part

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 ?

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

S�lectionner tout - Visualiser dans une fen�tre � part

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.

[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

[Flob90]

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

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

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)

[NoIdea]

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 :

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

[Invit�]

Ave ce code c'est tr�s simple :

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

[NoIdea]

Il faut donc mettre des auto partout... ok merci je test tout de suite.

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

[NoIdea]

J'ai sortit tout sa du namespace anonyme, et j'obtiens plein de sorry,unimplemented avec gcc4.5

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

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

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

S�lectionner tout - Visualiser dans une fen�tre � part

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.

[NoIdea]

Je vais tester. Gcc 4.6 corrige ce bug ?

[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