von streambuf ableiten

Shade Of Mine

Hallo Leute!

Ich brauche einen stream der erst bei einem expliziten flush() oder beim destruktor aufruf den inhalt ausgibt.

mich wuerde interessieren was ihr zu meinem primitiven ansatz sagt - gibt es ne bessere moeglichkeit? sollte ich es anders machen?

#include<iostream>
#include<list>
#include<string>
using namespace std;

class Streambuf : public streambuf
{
private:
    list<string> buffer;

public:
    ~Streambuf()
    {
        sync(); //schreibe buffer inhalt
    }
protected:
    int xsputn(char const* s, int n)
    {   //statt auszugeben, speichern wir lieber
        string t(s,s+n);
        buffer.push_back(t);
        return n;
    }

    int sync()
    {   //alles flushen + buffer loeschen
        list<string>::iterator i=buffer.begin();
        list<string>::iterator end=buffer.end();
        while(i!=end)
        {
            cout<<*i;
            ++i;
        }
        buffer.clear();
        return 0;
    }
};

class Stream : public ostream
{
    Streambuf buf;
public:
    Stream()
    : ostream(&buf) //das ist doch hoffentlich sicher...?
    {
        init(&buf);  //geht es auch ohne dem?
        buf.pubseekoff(0,ios_base::beg);
    }
    Streambuf* rdbuf() const
    {
        return const_cast<Streambuf*>(&buf);
    }
};

int main()
{
    Stream s;
    s<<"hallo welt";
    cout<<"ich sage:\n";
    //gibt "ich sage:\nhallo welt" aus
}

ist es wirklich so einfach, oder habe ich etwas wichtiges uebersehen?

danke schonmal!

HumeSikkins

//das ist doch hoffentlich sicher...?

Nein. Nicht wirklich. Das ist mal eine der Situationen, wo private-Vererbung besser ist. Einfach

class Stream : private Streambuf, public ostream ...

dann bist du garantiert auf der sicheren Seite.

Shade Of Mine

HumeSikkins schrieb:

Nein. Nicht wirklich. Das ist mal eine der Situationen, wo private-Vererbung besser ist. Einfach
class Stream : private Streambuf, public ostream ...
dann bist du garantiert auf der sicheren Seite.

oh, danke!
es ist mir gleich komisch vorgekommen - aber mir kommt bei den streams so einiges komisch vor.

weisst du auch, was es mit dem init auf sich hat?
braucht man es, oder macht der ctor bereits alles?

waere doof, wenn der ctor es nicht machen wuerde, doch wozu braucht man init dann?

Shade Of Mine

noch ne frage - wenn Stream von Streambuf private erbt, was returned dann rdbuf()?

HumeSikkins

was returned dann rdbuf()?

z.B. this

weisst du auch, was es mit dem init auf sich hat?
braucht man es, oder macht der ctor bereits alles?

Das brauchst du, wenn du nicht private erbst. In diesem Fall könntest du erst 0 an den ostream-Ctor übergeben und dann nachher init aufrufen. Dann ist die Streambuffer-Instanzvariable auf jeden Fall erzeugt.

Shade Of Mine

danke!