Discussion :

[camboui]

Code :

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

1
2
3
	std::ostrstream ss;
	ss << '(' << __FILE__ << ", " << __LINE__ << ')' << std::endl;
	std::string s(ss.str());

Voici un simple code. Il apparait que dans "s" j'obtiens plein de caractères "parasites" derrière le retour de ligne. N'y a-t-il donc pas un '\0' à la fin comme dans tout C string "normal" ?

[Spout]

Salut,

Effectivement, c'est étonnant.
Cependant j'ai une question: est-ce lors de l'impression de la chaîne (affichage à l'écran, dans un fichier, ...), où est-ce seulement la représentation que t'en donne le debuggeur qui fait apparaitre ces fameux caractères?

[JolyLoic]

De mémoire, ostrstream demande des std::ends en fin de chaîne. Et il demande aussi de gérer des freeze de buffer. Il y a des cas où il peut être plus performant que ostringstream, mais ce n'est pas le cas ici (il faudrait lui passer un buffer pré-alloué).

Es-tu certain de ne pas vouloir utiliser ostringstream, qui est bien plus simple d'emploi ?

[camboui]

Oui, sans doute...
Merci.
C'est un foutoir ces stream je trouve... Quand utiliser lequel, où et pourquoi ?

[koala01]

Salut,

C'est pourtant simple... il faut utiliser

• ifstream si tu veux un fichier qui sera tout le temps lu
• ofstream si tu veux un fichier qui sera tout le temps écrit
• fstream si tu veux pouvoir passer d'un fichier en lecture à un fichier en écriture (et inversément)
• istringstream si tu veux convertir une chaine de caractères en n'importe quoi
• ostringstream si tu veux convertir n'importe quoi en chaine de caractères
• stringstream si tu veux pouvoir effectuer des conversions dans les deux sens
• istream si tu veux utiliser n'importe quel flux en lecture (qui peut être un fichier, un flux de conversion ou un flux d'entrée standard)
• ostream si tu veux utiliser n'importe quel flux en écriture (qui peut être un fichier, un flux de conversion ou un flux de sortie standard)

[g0up1l]

C'est un foutoir ces stream je trouve... Quand utiliser lequel, où et pourquoi ?

ha ha ouais, alors là je suis bien d'accord !
Et de fait le std::endl, ne met pas de caractère '\0'

[camboui]

Ok, donc je ne dois jamais utiliser ostrstream, soit.

Pour les istream et ostream, y a-t-il des exemples d'utilisation "utiles" ?
Par exemple, j'aimerais écrire soit dans un fichier log, soit sur la console, soit les deux, soit transférer vers une autre application, etc, le tout à la demande et dynamiquement (sans recompiler donc).
Merci.

[JolyLoic]

Ce que tu veux là, ce n'est pas les flux, mais un système de log, avec notion de destination multiples. Il en existe un certain nombre, mais pas de standard de fait.

[koala01]

La méthode "naïve" pourrait correspondre à deux variable booléennes globales, l'une servant à préciser s'il faut envoyer l'information vers la console, l'autre à préciser s'il faut l'envoyer un fichier log (en sommes, il faudrait alors prévoir de rediriger clog vers un fichier )

Tu prévoirais alors pour tes différentes classes la surcharge de l'opérateur << sous une forme proche de

Code :

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

1
2
3
4
5
6
7
8
9
10
friend std::ostream& oparator << (operator& ofs, const TonType& t)
{
    ofs<<t.champs1
        <<t.champs2
        <<" une information lisible"
        <<t.champs3
        /*...*/
        <<t.chamsN;
    return ofs;
}

(voir dans la FAQ comment t'y prendre avec les objets polymorphes)

Et tu t'amuserais à rajouter dans ta logique un code proche de

Code :

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

1
2
3
4
if(affichage_console)
    std::cout<<(*this); // ou std::cout<<variable;
if(envoi_log)
    std::clog<<(*this); // ou std::clog<<variable;

(ou affichage_console est le booléen demandant (ou non) l'affichage console et envoi_log celui demandant (ou non) l'envoi vers le fichier log)

Mais tu te rendra vite compte que cette implémentation "naïve" t'obligera à écrire ce code en énormément d'endroits différents, et donc une solution plus "souple" serait:
De surcharger l'opérateur << pour les classes qui doivent envoyer leurs information vers (la console et/ou le fichier log) et de créer un singleton proche de

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
 
/* nous allons avoir besoin de la classe string, des entrées/sorties standard
 * et des flux de fichiers
 */
#include <iostream>
#include <string>
#include <fstream>
class Sender
{
    public:
        static Sender& instance();
        /* permet de gérer s'il faut l'affichage console ou non */
        Sender& setConsole(bool);
        /* permet de gérer s'il faut l'envoi dans un log ou non; */
        Sender& setLog(bool l, const std::string& filename = "");
        template <class T>
        Sender& send(const T& t)
        {
             if(console)
                 std::cout<<t<<std::endl;
             if(log)
                 std::clog<<t<<std::endl;
            return *this;
        }
    private:
        Sender(){}
        ~Sender(){}
        static Sender* inst;
        static bool console;
        static bool log;
        /* pour être en mesure de réinitialiser clog à son comportement
         * par défaut
         */
        static std::streambuf* buf01;
        static std::ofstream* file;
};

L'implémentation prendrait la forme de

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
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
 
#include "Sender.hpp"
/* initialisation générale des variables statiques */
Sender* Sender::inst = NULL;
bool Sender::console = false;
bool Sender::log = false;
std::streambuf* Sender::buf01 = NULL;
std::ofstream* Sender::file = NULL ;
/* obtention de l'instance de notre singleton */
Sender& Sender::instance()
{
    if(!inst)
        inst=new Sender;
    return *inst;
}
/* permet de définir s'il faut un affichage console */
Sender& Sender::setConsole(bool c)
{
    console=c;
    return *this;
}
/* permet de définir s'il faut une écriture dans un fichier trace */
Sender& Sender::setLog(bool l, const std::string& filename)
{
    /* si l'on souhaite une écriture "log" */
    if(l)
    {
        /* si on ne précise pas de nom de fichier, c'est
         * que l'on souhaite que cela se fasse sur la sortie standard
         */
        if(filename=="")
        {
            /* si buf01 est défini, il faut récupérer le buffer d'origine
             */
            if(buf01)
            {
                std::clog.rdbuf(buf01);
                buf01 = 0;
            }
            /* et détruire proprement le fichier trace s'il existe */
            delete file;
            file = NULL;
        }
        else
        {
            /* sinon, nous détruisons le fichier trace s'il existe */
            delete file;
            /* pour en ouvrir un avec le bon nom
            file = new std::ofstream(filename.c_str(),std::ios_base::app);
            /* si on n'a pas encore le buffer de sauvegarde, on 
             * le défini en définissant le buffer de clog sur celui du 
             * fichier, sinon, nous définissons simplement le buffer
             * de clog sur celui du fichier
             */
            if(!buf01)
                buf01 = std::clog.rdbuf(file->rdbuf());
            else
                std::clog.rdbuf(file->rdbuf());
        }
        /* et nous prenons note du fait qu'il faut une écriture */
        log = true;
    }
    else
    {
        /* si on ne désire plus de fichier "log",
         * on détruit proprement le fichier,
         * on redéfini le buffer de clog à son état d'origine,
         * et on prend note qu'il ne faut plus d'écriture
         */
        delete file;
        file = NULL;
        if(buf01)
            std::clog.rdbuf(buf01);
        log = false;
    }
    return *this;
}

et l'utilisation pourrait se faire sous une forme proche de

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
#include "Sender.hpp"
int main()
{
    Sender::instance().setConsole(true)
                      .send("Salut console uniquement")
                      .setConsole(false)
                      .send("Salut non visible")
                      .setLog(true)
                      .send("salut log uniquement")
                      .setConsole(true)
                      .send("Salut console et log")
                      .setLog(true,"log.txt")
                      .send("Salut console et log (fichier)");
 
    return 0;
}

[EDIT]Tu l'auras compris, l'appel à setConsole et / ou setLog se fait de manière générale dans les "options de configuration", et l'appel à send se fait partout où, selon la configuration, il te faut un affichage (ou une sortie "log")

Au final, dans une classe donnée, cela peut prendre la forme de

Code :

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

1
2
3
4
5
void MaClass::foo()
{
    Sender::instance().send("nous somme dans la fonction foo de MaClass")
                      .send(*this);
}

[camboui]

Intéressant, merci.
J'ai ajouté ceci à ta classe Sender

Code :

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

1
2
3
4
5
6
7
8
9
	template <class T>
	Sender & operator<<(const T & t)
	{
		if (console)
			std::cout << t;
		if (log)
			std::clog << t;
		return *this;
	}

Et puis je fais un appel comme ceci

Code :

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

sender.setConsole(true) << 25 << " abc";

Mais lorsque je fais ceci, c'est badaboum, le compilateur ne veut pas

Code :

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

sender.setConsole(true) << 25 << " abc" << std::endl;

Par contre ceci est bon

Code :

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

sender.setConsole(true) << std::setw(4) << 25 << " abc";

Une idée pourquoi ? Quelle est la contrainte avec std::endl ?

[Jean-Marc.Bourguet]

Quelle est la contrainte avec std::endl ?

C'est une fonction template utilisee dans un contexte ou elle n'est pas deductible (il y a deux templates dont il faut deduire les arguments templates: endl et operator<<).

Normalement ajouter un membre:

Code :

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

Sender& operator<<(std::ostream& (*fn)(std::ostream&));

devrait regler ce probleme.

En passant, la technique que j'emploie pour faire cela est de me definir un streambuf (place dans un ostream) qui envoie au choix vers les deux streambufs cibles. C'est plus propre, ca evite de formater deux fois, on peut utiliser tout ce qui prend un ostream. La FAQ de fr.comp.lang.c++ contient un exemple de definition de streambuf.

[camboui]

En passant, la technique que j'emploie pour faire cela est de me definir un streambuf (place dans un ostream) qui envoie au choix vers les deux streambufs cibles. C'est plus propre, ca evite de formater deux fois, on peut utiliser tout ce qui prend un ostream. La FAQ de fr.comp.lang.c++ contient un exemple de definition de streambuf.

Je trouve aussi que c'est beaucoup plus propre. Tu as un lien direct vers l'exemple, ou simplement vers la faq dont tu parles ? (je ne trouve pas)

[Jean-Marc.Bourguet]

Je trouve aussi que c'est beaucoup plus propre. Tu as un lien direct vers l'exemple, ou simplement vers la faq dont tu parles ? (je ne trouve pas)

Malheureusement elle a l'air d'avoir ete viree... Bon, recourons aux grands moyens.

http://web.archive.org/web/200701280...sreis/C++/FAQ/

[Goten]

Sans passer par les archives elle est hébergé ici :

http://www.decima.org/c++/faq-fclc++.txt


quoique elle est moins complète apparemment.... surement une ancienne version.

[Jean-Marc.Bourguet]

Sans passer par les archives elle est hébergé ici :

http://www.decima.org/c++/faq-fclc++.txt

Je sais. Mais sans la partie qui interesse ici...

[Alp]

{o,i}strstream ne sont pas dépréciées, au passage ?

[JolyLoic]

Je ne sais plus leur status exact. Ils l'ont été, il me semble, mais comme ils remplissent un besoin non remplis par les autres (un gain d'allocation), je ne sais plus s'ils le sont encore.

[Jean-Marc.Bourguet]

Je ne sais plus leur status exact. Ils l'ont été, il me semble, mais comme ils remplissent un besoin non remplis par les autres (un gain d'allocation),

Ce n'est pas particulièrement le gain d'une allocation, c'est l'utilisation d'une zone mémoire bien spécifiée (en multithread, o

je ne sais plus s'ils le sont encore.

Dans le CD de C++0X, c'est toujours dans l'annexe D (Compatibility Features) et donc deprecated where deprecated is defined as: Normative for the current edition of the Standard, but not guaranteed to be part of the Standard in future revisions.

[camboui]

Allez, hop, résolu, et j'oublie l'existence de strstream au profit de stringstream

[camboui]

Une petite question. Comment connaître la longueur de ce qui est contenu dans un ostringstream ?
Pour l'instant je fais long p=ss.tellp(); mais je ne suis sûr que ce soit correct.
Merci.