Bonjour à tous,

Je suis en train de programmer une classe Logger qui me permettra de debugger mes programmes. J'ai un petit soucis sur l'écriture de données dans mon fichier. voici mon code :

Logger.h
class Logger{
public:
    Logger(const string FilName="OutPut.log");
    Logger(const Logger&){};
    ~Logger();

    void Log(const string& Msg);
    template <class T>
    Logger& operator <<(T &ToLog);

protected:
    ofstream m_File;
};
template <class T>
Logger &Logger::operator <<(T &ToLog)
{
    std::ostringstream Stream;
    Stream << ToLog;
    Log(Stream.str());

    return *this;
}

Logger.cpp
[...]
void Logger::Log(const string& Msg)
{
    m_File<<Msg;
}
[...]

Le probleme c'est que le fichier est vide que je fasse Log<<"Message" ou Log.Log("Message") dans la fonction main.
 J'ai executé le programme en pas à pas et à la ligne : m_File<<Msg, le message existe et est corecte. Si je remplace cette ligne par m_File<<Msg<<endl; a ce moment, le fichier est bien écrit.

Voila quelqu'un aurait il une idée sur ce qui se passe ?
Merci
Damien

NB: je suis sous linux (ubuntu) ca à peut être une influence.

---

*Les fautes d'orthographes jointes à la présente missive, sont la propriété exclusive de l'auteur. Toute copie illégale pourra être passive de poursuites judiciaires, et soumises à des peines et sanctions exemplaitres

Réponse acceptée !
C'est justement l'intéret de la classe Ofstream, c'est de bufferiser les écritures.
m_File << Msg << std::flush; <= si tu tiens absolument à ce que le fichier soit écrit immédiatement.

En l'absence de flush ou endl, le fichier sera écrit lorsque l'objet "m_File" le jugera nécessaire.

Génial merci beaucoup.

En fait si j'en ai besoin cest pour que je puisse choisir le moment ou faire le retour à la ligne. Par exemple :

Log<<"Message "<<Variable<< "Message"... je ne voulais pas qu'un retour à la ligne se fasse à chaque fois.

encore Merci et à plus
Damien

---

*Les fautes d'orthographes jointes à la présente missive, sont la propriété exclusive de l'auteur. Toute copie illégale pourra être passive de poursuites judiciaires, et soumises à des peines et sanctions exemplaires

Encore mieux :
Utiliser la spécialisition des templates :
const Logger &Logger::operator <<(const T &ToLog) const // en const c'est mieux, mais faire pour que le const n'impacte pas ton  objet, il reste le "mutable"
et
const Logger& Logger::operator <<(const Logger& ToLog) // pour ton logger, "mutable" ?

:D

J'ai pas trop compris, je vois ce qu'est la spécialisation des templates, mais pourquoi l'utiliser dans mon cas ? Pour choisir le moment de l'écriture dans le fichier ?

---

*Les fautes d'orthographes jointes à la présente missive, sont la propriété exclusive de l'auteur. Toute copie illégale pourra être passive de poursuites judiciaires, et soumises à des peines et san

La spécialisation n'aurait d'intéret que pour les types qui ne sont pas gérés par les stream de la STL (auquel cas, il suffirait de définir l'opérateur << et >>).

Pour le coup du "mutable", en général un logger est un singleton ou pas loin et donc on s'amuse pas a balader des instances constantes, donc perso, j'éviterais de définir les fonctions "const". Le coup du "mutable" ou du "const_cast", c'est quand meme pas clean clean. Ca doit etre réservé aux objets particuliers du style "mutex", etc...