Bonjour,

J'ai une classe dont l'un des membres est lié à un flux. Celui-ci peut soit être un ofstream, ou cout.

Le premier problème est que le premier doit être un membre à part entière, et le second ne peut être qu'une référence.

Plutôt que de spécialiser ma classe (assez grosse) pour chacun de ces deux cas, je définis un membre vers un wrapper qui lui sera spécialisé.

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
template <class T>
struct StreamWrapper;
 
template <>	// fichier
struct StreamWrapper<std::ofstream>
{
	typedef std::ofstream StreamType;
 
	StreamWrapper(std::string& outputFilePath) : outputStream(outputFilePath) { }
	std::ofstream	outputStream;
};
 
template <>	// console
struct StreamWrapper<std::ostream>
{
	typedef std::ostream StreamType;
 
	StreamWrapper(std::ostream& stream) : outputStream(stream) { }
	std::ostream&	outputStream;
};
 
template <class T>
struct A
{
    ...
    StreamWrapper<Stream> outStream;
    ...
};
J'ai par la suite voulu faire une surcharge de l'opérateur << :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
template <class T, typename V>
StreamWrapper<T>& operator<<(StreamWrapper<T>& stream, const V& value)
{
	return (stream << value);
}
mais l'utilisation de std::endl m'a posé un problème.
D'après ce que j'ai pu glaner sur le web, il faut faire en plus quelque chose du genre :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
template <>
StreamWrapper<std::ofstream>& operator<<(StreamWrapper<std::ofstream>& stream, std::ofstream& (*manip)(std::ofstream&))
{
	manip(stream.outputStream);
 
	return stream;
}
Mais bon, ça ne marche toujours pas. Il y un problème de résolution de template à la compilation.

Quelqu'un serait-il assez charitable pour me donner un coup de pouce ?
Merci.

PS : Que pensez-vous de ce livre ?