std::ostream ableiten und an Funktion übergeben

[MisterJ]

Hallo zusammen,

ich möchte eine Klasse so von std::ostream ableiten, dass ich sie einer Funktion übergeben kann, die ein std::ostream & erwartet.
Ziel des Ganzen ist es, dass ich in einer Worker-Klasse in einem extra Thread mehrere Funktionen aufrufe, deren Ausgaben dann per Signal an die GUI weitergeleitet werden sollen, so dass sie dann in einem QTextBrowser dargestellt werden.
Allerdings bin ich mir über das Vorgehen noch nicht ganz im klaren. Wenn ich es richtig verstanden habe, muss ich einen Konstruktor (und Destruktor) für die TextWriter-Klasse implementieren, da diese nicht von der abgeleiteten Klasse übernommen werden. Es will mir aber nicht so recht gelingen. Kann ich einfach den <<-Operator überladen, oder muss ich noch andere Funktionen berücksichtigen? Ich habe noch etwas von der flush()-Funktion gelesen und dass man auf EOF prüfen sollte.

Mein bisheriger Versuch der TextWriter-Klasse sieht folgendermaßen aus:

Code: Alles auswählen

class TextWriter :
	public QObject, public std::ostream
{
	Q_OBJECT
public:
	TextWriter() : std::ostream((std::streambuf*)0) {};
	TextWriter & operator<< (QString const &str) {
        emit FORWARD_listWidget_Log_NewItem(str);
        return *this;
    }

signals:
	void FORWARD_QTextBrowser_NewItem(QString);
};

Muss der << Operator zwingend ein TextWriter & zurückgeben? Mir reicht es ja eigentlich, das Signal zu emittieren.
Wo genau sollte ich dieses Codestück einfügen? Im Moment habe ich es in einer .h-Date, die von mehreren Klassen inkludiert wird. Allerdings entsteht dadurch der Fehler, dass der <<Operator mehrfach definiert wurde (fatal error LNK1169: one or more multiply defined symbols found).

Vielen Dank für eure Vorschläge!

[Christian81]

Sorry aber von std::ostream ableiten ist nicht wirklich sinnig...
Besser einfach einen Operator definieren:

Code: Alles auswählen

namespace std {
  std::ostream&  operator<< (std::ostream& wstream, const MyObject& obj);
} //namespace std

[MisterJ]

Hallo Christian,

kannst du vielleicht kurz erläutern, wieso das in deinen Augen nicht sinnvoll ist?
Das Überladen des ostream <<Operators ist in meinem Fall nicht der gewollte Weg, da ich eine externen Funktion aufrufe, die ein std::ostream erwartet um in diesen die Ausgabe zu schreiben.
Sollte es jedoch trotzdem mit deinem Vorschlag möglich sein, kannst du dann bitte beschreiben, wie ich ein Signal aus dem Operator heraus senden kann?

Viele Grüße

[RHBaum]

generell:
DU arbeitest mit Qt, also nutze diese auch

Die STL ist super, effizient, toll ....
Nur das konzept der IO Streams krankt IMHO etwas, es ist zu alt zu unflexibel ....
Sprich, iostreams sind genau der teil der STL, der von modernen C++ gesichtspunkten her nicht so ideal implementiert ist.
Ich bin sonst eher Fan der STL und bevorzuge diese ... aber die bindest Dich eh an die Qt, und grad hier bekommst du bessere Alternativen.

Du willst was implementieren,wass nur mit strings umgehen kann ! Alles andere wird in strings konvertiert, richtig ?
std::ostream ist aber binär ! QIODevice ist binaer ....
QTextStream macht dir eine convertierung von beliebigen typen zu String basierter Ausgabe über binär.
Du willst aber nicht binaer, du willst (Q)string !

Dieses verhalten gibts IMHO noch gar nicht .... d.h. es ist fraglich ob du ueberhaupt ein vorhandenes verhalten nachahmen musst !?
Soll sich das Ding wirklich wie ein Ausgabestrom verhalten ?

Was willst du genau erreichen:
Schreib mal auf, wie DU / deine Nutzer deine Komponente bedienen sollen !

Wenn doch, und wenn unbedingt iostream:
ostream und co machen nur die Transformation, Ziel ist immer der Streambuffer ...
Deine Komponente sollte also einen streambuffer implementieren, und der Nutzer wurde dann nur einen Stream drueberlegen.
Ableiten ist dann auch nicht das ziel ... sondern die beziehung ist generisch (template) du brauchst nur das streambuffer interface zu implementieren und kannst ihn dann auch als solchen verwenden.

Ciao ....