IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

SL & STL C++ Discussion :

surcharger std::endl ?


Sujet :

SL & STL C++

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Membre averti
    Homme Profil pro
    Consultant informatique
    Inscrit en
    Décembre 2007
    Messages
    27
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Isère (Rhône Alpes)

    Informations professionnelles :
    Activité : Consultant informatique
    Secteur : Industrie

    Informations forums :
    Inscription : Décembre 2007
    Messages : 27
    Par défaut surcharger std::endl ?
    Bonjour,

    Je me posais une question, sur la STL.

    Est il possible de surchager std::endl, ou la fonction flush ou put exécuter dans endl.

    Je souhaiterais faire un logger dérivant d'une std::ostream, pour pouvoir utiliser les << qui vont bien.

    Le truc serais que mon loggeur serait du pattern observer.

    Je log dans une classe sujet et quand j'appele std::endl, et bien la je notifie les observeurs concrets.

    Ce qui me permettrait d'avoir autant de loggeur différent (log fichier, console, bdd, réseau, debuger, fenetre etc ...) sans jamais trop me prendre la tête sauf pour le std::endl ;o)

    Ce que j'ai pour le moment

    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
     
    #include <iostream>
     
    class CLog : public std::ostream
    {
    public :
    	CLog(std::streambuf* stream) : std::ostream(stream) {}
     
    	_Myt& __CLR_OR_THIS_CALL operator<<(_Myt& (__cdecl *_Pfn)(_Myt&))
    	{	// call basic_ostream manipulator
    		_DEBUG_POINTER(_Pfn);
    		return ((*_Pfn)(*this));
    	}
     
    	CLog& __CLR_OR_THIS_CALL operator<<(CLog& (__cdecl *_Pfn)(CLog& Ostr))
    	{	// call basic_ostream manipulator
    		_DEBUG_POINTER(_Pfn);
    		return ((*_Pfn)(*this));
    	}
     
    	/*_CRTIMP2_PURE inline std::basic_ostream<char, std::char_traits<char> >&
    		__CLRCALL_OR_CDECL endl(std::basic_ostream<char, std::char_traits<char> >& _Ostr)
    	{	// insert newline and flush byte stream
    		_Ostr.put('\n');
    		_Ostr.flush();
    		return (_Ostr);
    	}*/
     
    	inline CLog& __cdecl endl(CLog& Ostr)
    	{
    		return Ostr;
    	};
     
    	_Myt& __CLR_OR_THIS_CALL put(char _Ch)
    		{	// insert a character
    /*		ios_base::iostate _State = ios_base::goodbit;
    		const sentry _Ok(*this);
     
    		if (!_Ok)
    			_State |= ios_base::badbit;
    		else
    			{	// state okay, insert character
    			_TRY_IO_BEGIN
    			if (_Traits::eq_int_type(_Traits::eof(),
    				_Myios::rdbuf()->sputc(_Ch)))
    				_State |= ios_base::badbit;
    			_CATCH_IO_END
    			}
     
    		_Myios::setstate(_State);*/
    		return (*this);
    		}
    };
     
    int main(void)
    {
    	CLog Log(0);
    	Log.rdbuf(std::cout.rdbuf());
    	Log << "Test";
    	Log << std::endl;
     
    	return EXIT_SUCCESS;
    }

    C'est un petit programme de test avant de me lancer dans le pattern Observer. Si je ne suis pas capable de trouver une solution, rien ne me sert de faire pour le moment mon observeur.

    Au passage je ne maitrise pas vraiment la STL, ceci me permettrait d'en connaitre un peu plus.

    Cordialement

    Ambroise Petitgenêt

  2. #2
    Membre émérite

    Profil pro
    Inscrit en
    Septembre 2006
    Messages
    717
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Septembre 2006
    Messages : 717
    Par défaut
    Les iostream n'ont pas été prévus pour être dérivés (pas de fonction virtuelle, notamment). Pour en changer le comportement on passe habituellement par la couche en dessous, les streambuf. Voir par exemple l'article de James Kanze sur les streambuf filtrants.

  3. #3
    Membre averti
    Homme Profil pro
    Consultant informatique
    Inscrit en
    Décembre 2007
    Messages
    27
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Isère (Rhône Alpes)

    Informations professionnelles :
    Activité : Consultant informatique
    Secteur : Industrie

    Informations forums :
    Inscription : Décembre 2007
    Messages : 27
    Par défaut
    Merci beaucoup,

    j'ai fait dérivé de streambuf, j'ai surchargé sync et overflow, et ca marche

    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
    class CLog : public std::streambuf
    {
    public:
    	CLog(int bufferSize) 
        {
            if (bufferSize)
            {
                char *ptr = new char[bufferSize];
                setp(ptr, ptr + bufferSize);
            }
            else
                setp(0, 0);
        }
     
     
    	virtual void writeString(const std::string &str)
        {
            /*OutputDebugString*/(str.c_str());
        }
     
     
    private:
    	int	overflow(int c)
        {
            sync();
     
            if (c != EOF)
            {
                if (pbase() == epptr())
                {
                    std::string temp;
                    temp += char(c);
                    writeString(temp);
                }
                else
                    sputc(c);
            }
     
            return 0;
        }
     
        int	sync()
        {
            if (pbase() != pptr())
            {
                int len = int(pptr() - pbase());
                std::string temp(pbase(), len);
                writeString(temp);
                setp(pbase(), epptr());
            }
            return 0;
        }
     
    };
     
    int main(void)
    {
    	CLog Log(256);
     
    	std::cout << "out to console" << std::endl;
     
    	// set tje new buffer
        std::streambuf *old_buffer = std::cout.rdbuf(&Log);
     
    	// Log in the buffer
        std::cout << "to visual studio debug output window" << std::endl;
     
        // restore the old buffer
        std::cout.rdbuf(old_buffer);
     
    	//Log << "Test";
     
    	return EXIT_SUCCESS;
    }
    Bon j'avoue j'ai un peu chercher sur le net ce code n'est pas trop de moi

    http://www.devmaster.net/forums/showthread.php?t=7037

    Je vais pouvoir continuer mon idée: plus qu'a mettre mon système d'observeur en place

    Merci encore

    ambroise

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. std::endl vs '\n'
    Par r0d dans le forum C++
    Réponses: 20
    Dernier message: 24/09/2013, 15h08
  2. faire comme std::endl
    Par mister3957 dans le forum C++
    Réponses: 4
    Dernier message: 21/01/2010, 14h03
  3. Problème de surcharge d'opérateur std::cout
    Par Nyko17 dans le forum C++
    Réponses: 14
    Dernier message: 28/04/2008, 13h01
  4. Surcharge d'opérateur << et std::endl;
    Par Tourix dans le forum SL & STL
    Réponses: 7
    Dernier message: 29/06/2006, 17h58
  5. std::endl c'est quoi ??
    Par elekis dans le forum SL & STL
    Réponses: 8
    Dernier message: 14/09/2005, 17h15

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo