Discussion :

[sopsag]

Bonjour à tous,

j'ai une classe qui surcharge l'opérateur << pour permettre la sortie formatée vers un ostream.

Je veux que l'utilisateur de ma classe puisse déclarer son propre ostream-like avec une sortie formatée à lui.
Tout marche comme je veux sauf pour le retour à la ligne avec endl.
Voici un petit bout de code (ultra simplifié) qui illustre mon cas:

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
struct Point // ma classe
    {
    int x,y ;
 
    // avec sa surcharge de l'opérateur de sortie formatée
    template <typename output>
    friend output & operator<< ( output & o , const Point & t ) ;
    } ;
 
// implémentation de l'opérateur de sortie formatée
template <typename output> output & operator<< ( output & o , const Point & t )
    {
    o << "(" << t.x << "," << t.y << ")" ;
    // o << output::endl ; // ne compile pas avec o == std::cout car endl n'est pas membre de std::ostream
    return o ;
    }
 
// le ostream-like de l'utilisateur
struct my_ostream
    {
    my_ostream & operator<< ( int x )                       { printf("int    : %d\n",x ) ; return *this ;}
    my_ostream & operator<< ( const char * s )              { printf("string : \"%s\"\n",s ) ; return *this ;}
    my_ostream & operator<< ( my_ostream&(*f)(my_ostream&)) { return f( *this ) ;}
    // le "endl" de my_ostream a la même signature que celui de std :
    static my_ostream & endl ( my_ostream & o )             { printf("end of line\n") ; return o ;}
    } ;
 
void test_output2 ()
    {
    Point p = { 12,13 } ;
    my_ostream my_cout ;
    my_cout << p ;
    std::cout << p ; // si je commente cet appel, le "o << output::endl" du dessus compile bien.
    }

Quelqu'un saurait-il comment faire (proprement) ce genre de truc ?

[atttchoum]

Bonjour,

Peut être

Code :

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

static const char endl = '\n';

Après tout c'est juste pour signaler une fin de ligne

[nikko34]

en fait le endl fait un flush aussi

[sopsag]

En fait, ce que je voudrais, c'est pouvoir faire ces 2 appels et que ça marche !

Code :

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

1
2
my_cout << p ;   // utilise un ostream perso
std::cout << p ; // utilise le ostream des stl

Or, dans mon exemple, l'appel "<< endl" dans ma surcharge de l'opérateur << ne compile pas pour la 2eme ligne.

[Davidbrcz]

output est un type et en gros tu es en train de demander à ton compilateur de compiler un appel std::ostream::std::endl, ce qui n'a pas de sens, std::endl n'étant absolument pas membre de std::ostream

[Jean-Marc.Bourguet]

La maniere habituelle de faire son "ostream like" est de definir un streambuf -- apres quoi tu n'as plus de probleme.

[sopsag]

std::endl n'étant absolument pas membre de std::ostream

Bé oui, je sais bien, d'où ma question...
Mais merci pour ce lien précieux ! de longues heures de lecture en perspectives... toutefois j'ai peur de ne pas y trouver ma réponse.

Pour mon machin, la solution de atttchoum est celle vers laquelle je me dirigeais... ça donne un truc comme ça

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
struct my_ostream
    {
    // j'ajoute cette méthode qui va traduire les manipulateurs
    template <class c, class t>
    my_ostream & operator<< ( std::basic_ostream<c,t>&(*f)(std::basic_ostream<c,t>&)) 
        { 
        switch ( f )
            {
            case std::endl : my_ostream::endl( *this ) ;
            case std::ends : ; // etc
            }
        return *this ;
        }

Ça ne compile pas et je n'ai encore compris pourquoi...
Mais de toutes façons, je trouve ça assez moche.

Quant à la solution de Jean-Marc Bourguet à base de streambuf, je ne la comprends pas...