Discussion :

[oodini]

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 ?

[Flob90]

Bonsoir,

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
 
#include<iostream>
 
namespace N
{
 
template<class T>
struct A
{
    A(T& out)
        : out(out) {}
    T& out;
};
 
template<class T, class U>
A<T>& operator<<(A<T>& a, const U& u)
{ a.out << u; return a; }
 
template<class T>
A<T>& operator<<(A<T>& a, T& (*m)(T&))
{ a.out << m; return a; }
 
}
 
int main()
{
    N::A<std::ostream> a(std::cout);
    a << 0 << std::endl;
}

Fonctionne parfaitement.

[oodini]

Code :

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

1
2
3
4
5
6
struct A
{
    A(T& out)
        : out(out) {}
    T& out;
};

out n'est une référence que si T est std::cout. Si c'est un fichier, c'est une instance de ifstream. D'où mon utilisation d'un wrapper. Et c'est peut-être là que ça complique les choses.

[backlash]

2 problèmes :

- Tu fais une mauvaise utilisation du mot-clé typename.

- Ta spécialisation totale ne matchait pas la fonction générique.

Une correction potentielle :

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
template <class T, typename V>
StreamWrapper<T>& operator<<(StreamWrapper<T>& stream,  const V& value)
{
	return (stream << value);
}
 
typedef std::ofstream& (*func_ptr)(std::ofstream&); //voir la note
 
template<>
StreamWrapper<std::ofstream>& operator<<(StreamWrapper<std::ofstream>& stream,  const func_ptr& manip)
{
	manip(stream.outputStream);
 
	return stream;
}

NOTE : à tester avec le mot clé using

[oodini]

- Tu fais une mauvaise utilisation du mot-clé typename.

C'était un reliquat d'une aute tentative où le typename était nécessaire...
Je les ai viré dans mon 1er emssage. Merci de la remarque.

- Ta spécialisation totale ne matchait pas la fonction générique.

Je n'ai pas compris ce que tu as changé, mis à part l'utilisation du typedef.

[Flob90]

Ma classe A c'était ta classe StreamWrapper :

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
 
namespace N
{
 
template<class T>
struct SW;
 
template<class charT, class traits>
struct SW<std::basic_ostream<charT,traits> >
{
    typedef 
        std::basic_ostream<charT,traits>& 
        (*manip)(std::basic_ostream<charT,traits>&);
    std::basic_ostream<charT,traits>& out;
    SW(std::basic_ostream<charT,traits>& out)
        : out(out) {}
};
 
template<class charT, class traits>
struct SW<std::basic_ofstream<charT,traits> >
{
    typedef 
        std::basic_ostream<charT,traits>& 
        (*manip)(std::basic_ostream<charT,traits>&);
    std::basic_ofstream<charT,traits> out;
    template<class S>
    SW(S out)
        : out(out) {} 
};
 
template<class T, class U>
SW<T>& operator<<(SW<T>& sw, const U& u)
{ sw.out << u; return sw; }
 
template<class T>
SW<T>& operator<<(SW<T>& sw, typename SW<T>::manip m)
{ sw.out << m; return sw; }
 
}