Discussion :

[boromir73]

Je souhaiterais utiliser la fonction copy pour afficher une liste de listes.

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>
#include <iterator>
#include <list>
#include <algorithm>
 
using namespace std;
 
typedef list<int> IntList;
typedef list<IntList> ListList;
 
ostream& operator<<(ostream& os, const IntList& l) {
	copy(l.begin(),l.end(),ostream_iterator<int>(cout,"\t"));
	return os;
}
 
int main() {
	ListList l(2,IntList(2));
	copy(l.begin(),l.end(),ostream_iterator<IntList>(cout,"\n")); // Erreur de compilation
	return 0;
}

Compilé avec g++ 3.4.2 sous Windows XP, le code ci-dessus génère une masse de messages d'erreurs (en substance : " no match for 'operator<<' " au niveau de l'opérateur 'operator=' de ostream_iterator).

Qu'est-ce qui ne va pas ?

[boromir73]

J'ai copié-collé la définition de ostream_iterator présente dans l'en-tête 'stream_iterator.h', et la compilation s'est déroulée sans erreur. La seule différence entre ma source et la définition dans 'stream_iterator.h' était la présence de 'namespace std { }'.

Voici donc la version corrigée du programme :

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
 
#include <iostream>
#include <iterator>
#include <list>
#include <algorithm>
 
using namespace std;
 
typedef list<int> IntList;
typedef list<IntList> ListList;
 
namespace std {
 
	ostream& operator<<(ostream& os, IntList const& l) {
		copy(l.begin(),l.end(),ostream_iterator<int>(cout,"\t"));
		return os;
	}
 
} // namespace std
 
int main() {
	ListList l(2,IntList(2));
	copy(l.begin(),l.end(),ostream_iterator<IntList>(cout,"\n"));
	return 0;
}

[boromir73]

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 toto {
	class A {};
 
	void f(int) { std::cout << "f(int)\n"; }
 
	template<typename T> void g(const T& t) { f(t); }
}
 
using namespace toto;
 
namespace toto {
	void f(const A&) { std::cout << "f(const A&)\n"; }
}
 
int main() {
	g(A());
	return 0;
}

Pour que le code ci-dessus compile, il faut soit :

• qu'aucune fonction f ne soit définie dans toto
• que toutes les surcharges de f soient définies dans toto

Je crois que j'ai compris pourquoi.

Quand le compilateur définit la fonction g<A>(A), il voit que le paramètre de f() appartient au namespace toto et va chercher une définition de f() dans toto. S'il y en a une avec le bon type, ok. S'il y en a mais pas avec le bon type de paramètre, erreur (et pas de recherche ailleurs, d'où le problème avec ostream_iterator). S'il n'y en a pas, il va chercher parmi les fonctions accessibles dans tout le fichier.

Si quelqu'un pouvait confirmer, ce serait sympa.

[b Oo]

Merci boromir73 pour cette explication.

Je pense juste que tu as fais une erreur de frappe.

Quand le compilateur définit la fonction g<A>(A), il voit que le paramètre de f() appartient au namespace toto et va chercher une définition de f() dans toto.

Je dirais plutôt :
Quand le compilateur définit la fonction g<A>(A), il voit que le paramètre de g() (c'est-à-dire A) appartient au namespace toto et il va chercher une définition de f() dans toto.

A function taking an argument of type T is more often than not defined in the same namespace as
T Consequently, if a function isn’t found in the context of its use, we look in the namespaces of its T arguments.