Discussion :

[CedricMocquillon]

Bonjour à tous,

je n'arrive pas à comprendre pourquoi le code suivant 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 <fstream>
#include <vector>
#include <iterator>
 
namespace foo
{
 
template<typename T=double>
struct Bar
{
	T baz;
};
 
}
 
std::istream& operator>>(std::istream& in, foo::Bar<>& f)
{
	return in >> f.baz;
}
 
int main()
{
	std::ifstream f("test.txt");
	std::istream_iterator<foo::Bar<>> Begin(f);
	std::istream_iterator<foo::Bar<>> End;
	std::vector<foo::Bar<>> data(Begin, End);
}

Le compilateur me renvoie:

error C2679: '>>' binaire*: aucun opérateur trouvé qui accepte un opérande de partie droite de type 'foo::Bar<>' (ou il n'existe pas de conversion acceptable)

alors que celui-ci compile:

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 <fstream>
#include <vector>
#include <iterator>
 
namespace foo
{
 
template<typename T=double>
struct Bar
{
	T baz;
};
 
std::istream& operator>>(std::istream& in, Bar<>& f)
{
	return in >> f.baz;
}
 
}
 
int main()
{
	std::ifstream f("test.txt");
	std::istream_iterator<foo::Bar<>> Begin(f);
	std::istream_iterator<foo::Bar<>> End;
	std::vector<foo::Bar<>> data(Begin, End);
}

(Je compile sous Visual 2008). Il semblerait que la surcharge des opérateurs de flux doive "vivre" dans le même namespace que l'objet pour lequel on réalise cette surcharge mais je n'arrive pas à comprendre pourquoi (est-ce une limitation de visual ou est-ce lié directement au langage / norme)

[oodini]

Il faudrait peut-être rappeler avant la définition de l'opérateur que Bar est templatisé.

[ternel]

Bonjour,
Apparemment, c'est un comportement standard lié à l'ordre de résolution des namespace et des surcharges.

Je suis tombé sur le problème récemment, et j'avais trouvé cette explication sur stackoverflow.com.

[Jean-Marc.Bourguet]

La résolution de surcharge, c'est complique...

Elle se fait en deux phases: premièrement, collecte des définitions possibles, deuxièmement, choix d'une d'entre elle. Je ne vais pas traiter de la deuxième phase, elle n'est pas problématique ici.

Les définitions vues sont celles
- qui sont actives dans le namespace actif, ici std (puisqu'on cherche ce qui est fait dans l'instanciation d'un template defini dans std). Comme il y a des définitions dans std, ce sont celles de std et on ne va pas voir dans le namespace global. (S'il n'y avait pas de définition de operator>> dans std, on irai voir dans le namespace global; on a le même effet d'espace de nommage imbriques avec des classes ou sans using on peut masquer une definition dans la classe de base).
- qui sont presentes dans les namespaces ou sont definis les types des arguments

Dans ton cas, ca fait les definitions de std (parce que tu es dans la definition de std::stream_iterator), les definitions de std a nouveau (un des types d'argument est std::istream) et de foo (l'autre argument est foo::bar). Dans ton premier cas, la definition que tu desires est dans le namespace global et n'est pas consideree. Dans le deuxieme cas, la definition que tu desires est dans foo et donc est consideree par la deuxieme regle.

Un aspect piegeux, c'est que si tu cherches quelque chose qui n'a pas de definition dans le namespace std, tu vas le chercher dans le namespace global.

Donc en utilisant un autre namespace,

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>
namespace ns {
template <typename T> void f(std::istream& is, T& t) { is >> t; }
}
 
namespace foo {
template<typename T=double> struct Bar {
	T baz;
};
}
 
std::istream& operator>>(std::istream& in, foo::Bar<>& f) {
	return in >> f.baz;
}
 
int main() {
    foo::Bar<> fb;
    ns::f(std::cin, fb);
}

va marcher (il n'y a pas de definition d'operator>> dans ns, donc on va voir dans le namespace global pour la premiere etape). Tandis que

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
#include <iostream>
namespace ns {
struct S {};
std::istream& operator>>(std::istream&, S&);
template <typename T> void f(std::istream& is, T& t) { is >> t; }
}
 
namespace foo {
template<typename T=double> struct Bar {
	T baz;
};
}
 
std::istream& operator>>(std::istream& in, foo::Bar<>& f) {
	return in >> f.baz;
}
 
int main() {
    foo::Bar<> fb;
    ns::f(std::cin, fb);
}

ne va pas marcher car std::istream& operator>>std::istream&, S&) va empecher de chercher dans le namespace global dans la premiere etape. (En prime, il peut y a avoir des problemes lies aux templates qui font cette recherche potentiellement a deux moments differents, j'ai passe dessus).

En resume, il vaut effectivement mieux definir tout ce qui est proche d'un type -- les operateurs et des "operations primitives" comme une fonction swap non membre par exemple -- dans le namespace ou est defini le type. Et quand on defini un template, il faut appeler ces operateurs/fonctions de maniere non qualifiee.

Code :

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

1
2
 
{ using std::swap; swap (a, b); }

plutot que

Code :

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

std::swap(a, b);

pour aller les chercher dans les namespaces des operandes.

[CedricMocquillon]

Merci c'est vraiment très clair comme explication

[ternel]

Merci aussi, j'ai appris quelque chose aujourd'hui.