Flux & redéfinition de l'opérateur <<

Version imprimable

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:

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:

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:

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 ?

Bonsoir,

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
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.

02/05/2013, 10h16
oodini
Code:

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.

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:

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

02/05/2013, 14h42
oodini

Citation:

Envoyé par backlash

- 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.

Citation:

Envoyé par backlash

- 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.

Ma classe A c'était ta classe StreamWrapper :

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
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; }
 
}

02/05/2013, 23h08
JolyLoic

Je n'aime pas trop cette idée de classe parfois possédant un objet, parfois n'en possédant pas. Pourquoi ne pas simplement stocker une référence à un ostream dans ta classe, et gérer la durée de vie du fstream ailleurs, par exemple en tant que variable locale à une fonction genre main ?

C'est justement ce que je veux éviter.

J'ai plusieurs instanciations de ma classe la plus dérivée, avec variation de la valeur du template. Chaque instance doit se voir attachée un fichier de sortie qui lui est propre.

Ça ressemble à quelque chose comme ça (BaseFunctor est un type Erasure) :
Code:

1 2 3 4 5 6 7 8 9 10 11 //typedef std::ostream OutStream; typedef std::ofstream OutStream; typedef BaseFunctor<OutStream> StreamedFunctor; std::array<std::shared_ptr<BaseFunctor<OutStream>>, 4> fctArray; fctArray[0] = std::shared_ptr<StreamedFunctor>(new Functor_1<float, OutStream>(n, std::string("fichier1.csv"))); fctArray[1] = std::shared_ptr<StreamedFunctor>(new Functor_2<float, OutStream>(n, std::string("fichier2.csv"))); fctArray[2] = std::shared_ptr<StreamedFunctor>(new Functor_3<float, OutStream>(n, std::string("fichier3.csv"))); fctArray[3] = std::shared_ptr<StreamedFunctor>(new Functor_4<double, OutStream>(n, std::string("fichier4.csv")));
L'intérêt, c'est que je n'ai qu'à jouer du commentaire sur les 2 premières lignes. Si je commente la première, les noms de fichiers sont utilisés pour créer lesdits fichiers et les remplir. Si je commente la seconde, tout va vers std::cout, et le second argument n'est pas utilisé.

02/05/2013, 23h58
oodini

Flob90, je te remercie beaucoup !

J'ai réussi à appliquer ce que tu m'as indiqué dans une version allégée (bien qu'encore lourde) de mon code, mais je n'arrive pas encore à le faire compiler dans mon code d'origine. Je ne désespère pas d'y arriver.