surcharger std::endl ?

Version imprimable

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:

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

28/03/2009, 11h35
Sylvain Togni

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.

Merci beaucoup,

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

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