question sur la fonction bind

Version imprimable

25/10/2010, 22h44
deubelte

question sur la fonction bind
Bonjour

J'ai une question concernant l'utilisation de bind

La fonction std::get<0> permet de récupérer le premier élément d'une paire
et std::get<1> le deuxième.

la fonction bind est définie ici:
http://msdn.microsoft.com/en-us/library/bb982702.aspx

Par exemple, quand on fait:

Code :

Code:

bind(cos, 1.0)

Ca renvoie cos(1.0).

Maintenant, quand je fais ceci:

Code :
Code:

1 2 pair<int, double> UnePaire0 =make_pair(20,3.2); bind(std::get<0,int,int>,UnePaire0);
ou

Code :
Code:

1 2 pair<int, double> UnePaire0 =make_pair(20,3.2); bind(std::get<0>,UnePaire0);
ca me renvoie des erreurs, alors que

Code :

Code:

std::get<0>(UnePaire0)

fonctionne très bien.

Avez vous une idée?
Merci

Bonjour.

Citation:

Envoyé par deubelte

ca me renvoie des erreurs

Ce serait pas mal de dire lesquelles...

Tu as essayé ça ?
Code:

1 2 std::pair<int, double> UnePaire0 = std::make_pair(20, 3.2); std::bind(std::get<0, int, double>, UnePaire0);
En y réfléchissant, je ne suis pas sûr qu'on puisse passer une fonction template en paramètre d'une autre fonction template...
Je ne suis pas assez calé pour ça.

Sinon, les foncteurs select1st et select2nd peuvent être utiles.
Par contre, ce sont des extensions GNU, alors ils ne sont pas forcément disponibles partout.
Code:

1 2 3 4 5 #include <ext/functional> std::pair<int, double> UnePaire0(20, 3.2); __gnu_cxx::select1st< std::pair<int, double> >()(UnePaire0) // std::get<0>(UnePaire0) => 20 __gnu_cxx::select2nd< std::pair<int, double> >()(UnePaire0) // std::get<1>(UnePaire0) => 3.2
Steph.

En fait, sur ma distribution, select1st et select2nd ne sont que des sous-classes vides de respectivement _Select1st et _Select2nd, définies dans un fichier appelé depuis l'en-tête <functional>, et appartenant à l'espace de nom std.

Pour information, en voici le 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
25
26
template<typename _Pair>
struct _Select1st : public unary_function<_Pair,
                                          typename _Pair::first_type>
{
    typename _Pair::first_type&
    operator()(_Pair& __x) const
    { return __x.first; }
 
    const typename _Pair::first_type&
    operator()(const _Pair& __x) const
    { return __x.first; }
};
 
 
template<typename _Pair>
struct _Select2nd : public unary_function<_Pair,
                                          typename _Pair::second_type>
{
    typename _Pair::second_type&
    operator()(_Pair& __x) const
    { return __x.second; }
 
    const typename _Pair::second_type&
    operator()(const _Pair& __x) const
    { return __x.second; }
 };

26/10/2010, 17h34
deubelte

Citation:

Sinon, les foncteurs select1st et select2nd peuvent être utiles.
Par contre, ce sont des extensions GNU, alors ils ne sont pas forcément disponibles partout.

je suis sur VC2010.

Citation:

En y réfléchissant, je ne suis pas sûr qu'on puisse passer une fonction template en paramètre d'une autre fonction template...

bind n'est pas template. Il n'y a qu'une fonction tempalte ici, c'est la fonctions std::get<>
26/10/2010, 18h48
Flob90
Code:

1 2 3 4 5 template<class F, class... BoundArgs> unspecified bind(F&&, BoundArgs&&...); template<class R, class F, class... BoundArgs> unspecified bind(F&&, BoundArgs&&...);
bind est bien template.

Je crois que le problème vient du fait qu'il y a deux version de get qui ont des signature différentes et que donc bind n'arrive pas à déterminer tout seul ses paramètre template.

Une solution est de passer par une fonction intermédiaire dont le compilateur pourrait déterminer la signature sans ambiguité.
Code:

1 2 3 4 template<size_t I, class T1, class T2> T1 tmp(const std::pair<T1, T2>& p) { return std::get<I>(p); }
Et l'utiliser dans bind à la place de get. (de la même manière)
26/10/2010, 19h27
Steph_ng8
Citation:

Envoyé par deubelte

Citation:

Sinon, les foncteurs select1st et select2nd peuvent être utiles.
Par contre, ce sont des extensions GNU, alors ils ne sont pas forcément disponibles partout.

je suis sur VC2010.

Oui, je m'en doutais un peu.
C'est pour cela que je t'ai mis le code des foncteurs.

Du coup tu as le choix :
- soit tu utilises l'astuce de Flob90 ;
- soit tu réécris ces foncteurs.
26/10/2010, 20h09
Arzar
Citation:

Envoyé par Flob90

Je crois que le problème vient du fait qu'il y a deux version de get qui ont des signature différentes et que donc bind n'arrive pas à déterminer tout seul ses paramètre template.

Oui c'est ça.
Il y a un conflit entre les deux fonctions :
Code:

1 2 3 4 5 template<typename IDX, typename T1, typename T2> type_retour& get(std::pair<T1, T2>& p); template<typename IDX, typename T1, typename T2> const type_retour& get(const std::pair<T1, T2>& p);
Il faut lever l'ambiguité en précisant le type de retour souhaité à bind:
Code:

1 2 std::pair<int, double> UnePaire0 = std::make_pair(20, 3.2); std::bind<int&>(std::get<0, int , double>, UnePaire0);
26/10/2010, 22h48
deubelte
Code:

1 2 Oui c'est ça. Il y a un conflit entre les deux fonctions :
Ok, la seule différence entre les deux, c'est le fait que le type retourné pour l'un est constant, et non pour l'autre.

Code:

const type_retour& get(const std::pair<T1, T2>& p);

Mais je ne vois pas en quoi le fait de spéficier

std::bind<int&> permet de lever l'ambiguité sur la constante.

De plus, dans ce cas, on appelle quelle version des deux fonctions?

Merci
26/10/2010, 23h26
Arzar

Citation:

Envoyé par deubelte

Mais je ne vois pas en quoi le fait de spéficier

std::bind<int&> permet de lever l'ambiguité sur la constante.

Ben car pour sélectionner la version constante il faudrait écrire : std::bind<const int&> ...
26/10/2010, 23h56
deubelte

Ok, si je reprends la définition de bind, j'ai:

Code:

bind<typename _Ret,typename _Fty>(_Fty _Val)

Pourquoi est il pas nécessaire de spécifier le deuxième argument template?
je m'attendais à faire: bind<Type1, Type2>
27/10/2010, 00h39
Steph_ng8

D'une manière générale, il n'est pas nécessaire de préciser explicitement la valeur des variables template que le compilateur peut déterminer tout seul (autrement dit, sans qu'il y ait d'ambiguïté).
C'est pour cette raison que l'on peut ne spécifier qu'un paramètre template à la fonction std::get, alors qu'elle en a trois : les deux autres sont déterminés automatiquement à partir du type de l'argument passé à la fonction.
Mais ce n'est pas une erreur d'indiquer explicitement tous les paramètres template, à condition de rester cohérent.

Pour le problème qui nous intéresse, comme il l'a été dit plus haut, le compilateur ne sait pas laquelle des deux fonctions std::get il doit utiliser.
Normalement, cette ambiguïté est levée grâce à la signature de la fonction, sauf qu'ici elle est censée être trouvée toute seule.
Les paramètres template pourraient différencier les fonctions, sauf qu'ils sont identiques dans les deux cas.

Heureusement, le type de retour, qui est différent pour les deux fonctions, et requis pour la fonction std::bind.
Une fois qu'il est défini, il n'y a plus qu'une seule fonction qui correspond, et l'ambiguïté est levée. :ccool:
27/10/2010, 09h08
deubelte

Citation:

D'une manière générale, il n'est pas nécessaire de préciser explicitement la valeur des variables template que le compilateur peut déterminer tout seul (autrement dit, sans qu'il y ait d'ambiguïté).

Je viens réellement d'apprendre qqch. Je pensais qu'on pouvait effectivement ne pas spécifier les tempalte quand on avait des paramètres template par défaut.
Mais y a pas de paramètres par défaut dans cette fonction bind.

Mais dans ma distribution, quand je fais :

Code:

std::bind<int&>(std::get<0>, UnePaire0);

j'ai comme erreur:

1>------ Build started: Project: Proj1, Configuration: Debug Win32 ------
1> src1.cpp
1>c:\users\visual studio 2010\projects\proj1\proj1\src1.cpp(77): error C2664: 'std::tr1::_Bind_fty<_Fty,_Ret,_BindN> std::tr1::bind<int&,std::pair<_Ty1,_Ty2>>(_Fty,_Arg0)' : cannot convert parameter 1 from 'overloaded-function' to 'int &'
1> with
1> [
1> _Fty=int &,
1> _Ret=std::tr1::_Notforced,
1> _BindN=std::tr1::_Bind1<std::tr1::_Callable_obj<int &,false>,std::pair<int,double>>,
1> _Ty1=int,
1> _Ty2=double,
1> _Arg0=std::pair<int,double>
1> ]
========== Build: 0 succeeded, 1 failed, 0 up-to-date, 0 skipped ==========

Fuseau horaire GMT +2. Il est actuellement 00h14.