<![CDATA[Mein eigenes Streamobjekt?]]>Was muss ich tun um ein eigenen Streamobjekt zu basteln? Also sowas wie cout, nur dass ich da entscheiden will wo der Stream hingeht, also in eine Datei, oder als Ausgabe auf der Konsole, oder, oder, oder.

]]>https://www.c-plusplus.net/forum/topic/325472/mein-eigenes-streamobjektRSS for NodeSun, 12 Jul 2026 18:15:10 GMTSun, 04 May 2014 14:54:31 GMT60<![CDATA[Reply to Mein eigenes Streamobjekt? on Sun, 04 May 2014 14:54:31 GMT]]>Was muss ich tun um ein eigenen Streamobjekt zu basteln? Also sowas wie cout, nur dass ich da entscheiden will wo der Stream hingeht, also in eine Datei, oder als Ausgabe auf der Konsole, oder, oder, oder.

]]>https://www.c-plusplus.net/forum/post/2397328https://www.c-plusplus.net/forum/post/2397328Sun, 04 May 2014 14:54:31 GMT<![CDATA[Reply to Mein eigenes Streamobjekt? on Sun, 04 May 2014 15:01:33 GMT]]>Wenn du nur den Stream umleiten willst, kannst du den internen Streambuffer umbiegen. Schau dir mal std::ostream::rdbuf() an.

]]>https://www.c-plusplus.net/forum/post/2397331https://www.c-plusplus.net/forum/post/2397331Sun, 04 May 2014 15:01:33 GMT<![CDATA[Reply to Mein eigenes Streamobjekt? on Sun, 04 May 2014 15:18:16 GMT]]>

Also sowas wie cout, nur dass ich da entscheiden will wo der Stream hingeht, also in eine Datei, oder als Ausgabe auf der Konsole, oder, oder, oder.

Also etwa in der Richtung?

#include <iostream>
#include <ostream>

class MyStreambuf : public std::streambuf
{
public:

	virtual int_type overflow( int_type ch = traits_type::eof() )
	{
		if( !traits_type::eq_int_type(ch, traits_type::eof()) )
			return std::cout.rdbuf()->sputc( traits_type::to_char_type(ch) );

		return traits_type::eof();
	}
};

int main()
{
	MyStreambuf buf;
	std::ostream stream(&buf);

	stream << "Hallo!\n";
}

Hier wird jedes Zeichen an cout weitergegeben. Kann man aber auch mit einem unterliegenden std::filebuf machen, um es in eine Datei zu lenken.

]]>https://www.c-plusplus.net/forum/post/2397335https://www.c-plusplus.net/forum/post/2397335Sun, 04 May 2014 15:18:16 GMT<![CDATA[Reply to Mein eigenes Streamobjekt? on Sun, 04 May 2014 15:49:27 GMT]]>Ja, ich glaube umbiegen trifft es ganz gut. Ich mystream << "hier kommt was" machen können und im Objekt selbst wird dann entschieden wohin umgeleitet wird, also Datei, die Konsole etc.

Arcoth, dein Code sieht ja höhst professionell aus, kannst du den etwas erklären? Ich will nicht einfach was benutzen, sondern auch verstehen.

]]>https://www.c-plusplus.net/forum/post/2397339https://www.c-plusplus.net/forum/post/2397339Sun, 04 May 2014 15:49:27 GMT<![CDATA[Reply to Mein eigenes Streamobjekt? on Sun, 04 May 2014 17:26:23 GMT]]>Es gibt in den I/O-Streams zwei Ebenen.
Die eine Ebenen sind die std::istream und std::ostream Klassenhierachien. Das sind die "höheren" Objekte, mit denen der normale User zu tun hat. std::cout z.B. ist vom Typ std::ostream, und du kennst garantiert std::ofstream und std::ostringstream für Dateien und Strings. Die erledigen in Wirklichkeit nicht die eigentliche Ein-/Ausgabe, sondern kümmern sich nur darum, dass Zahlen in Zeichenketten umgewandelt werden (bzw. umgekehrt), dass eine Ausgabebreite eingehalten wird und dass Fehlerzustände richtig gespeichert werden; so Formatierungszeugs halt. Die eigentliche I/O erledigen die Streambuffer. Ein Streambuf hat verschiedene Lowlevel-Funktionen. Er ist z.B. nur in der Lage einzelne Zeichen bzw. Zeichenketten ein/auszugeben, die Position im Stream zu setzen o.ä, aber erledigt nicht die eigentliche Formatierung. Der grundlegende Streambuffer ist std::streambuf. Davon abgeleitet gibt es einen Streambuffer, der in Dateien schreibt/von ihnen liest, einen der in Strings schreibt/von ihnen liest und du kannst selber auch welche schreiben, die z.B. Daten über Netzwerke transferieren.
Um die Arbeit für Leute, die so etwas schreiben, zu vereinfachen, ist die Funktionalität vieler Funktionen im std::streambuf schon vorgegeben. Es gibt bspw. die Funktion sputc, die ein Zeichen ausgeben soll. sputc schiebt dazu dieses Zeichen einfach in einen internen Buffer. Ist dieser interne Buffer voll, wird die virtuelle Funktion overflow aufgerufen, die diesen Buffer auf das Ausgabemedium schreiben soll. Diesen internen Buffer muss man jedoch erst setzen. Ist kein Buffer gesetzt - wie bei Arcoth - wird einfach direkt overflow aufgerufen.
Der Parameter für overflow ist das Zeichen, was nicht ausgegeben werden konnte. Es ist jedoch nicht einfach vom Typ char, weil es auch vorkommen kann, dass es kein solches Zeichen gibt. In diesem Fall wird das spezielle Zeichen eof übergeben. Aus diesem Grund ist der Parameter vom Typen int_type. int_type ist in der Lage, jedes Zeichen plus eof zu speichern. Der Rückgabewert ist eof, wenn kein Zeichen ausgegeben wurde - z.B. wegen einem Fehler, bzw. wenn eof übergeben wurde, ansonsten irgendein anderes Zeichen.
Was soll nun dieses traits_type? Nun, in Wirklichkeit sind all diese Klassen Templates. std::ostream ist in Wirklichkeit std::basic_ostream<char>. Ich weiß nicht, ob du weißt, was ein Template ist, deswegen werde ich da nicht so genau drauf eingehen. Wichtig ist nur: Es gibt verschiedene Encodings. ASCII ist ein simples Encoding, dort ist jedes Zeichen 1 Byte groß und passt somit wunderbar in ein char. Um ASCII-Strings auszugeben, muss man also mit chars arbeiten. UTF-32 hingegen ist ein Encoding, bei dem jedes Zeichen 4 Bytes groß ist. Man müsste also mit uint32_t arbeiten, anstatt mit char. Aus diesem Grund sind alle Streams konfigurierbar für den Typen, mit dem sie arbeiten. Um jetzt zu prüfen,ob in einem char 'A' drin steht, kann man einfach schreiben: character == 'A'. Es kann jedoch sein, dass es irgendein spezielles Encoding gibt, bei dem man das nicht so prüfen kann. Aus diesem Grund gibt es die Charactertraits. Die Charactertraits definieren die Operationen, die man mit diesen Typen machen kann. Z.B. gibt es dort die Funktion eq, die prüft ob ein Zeichen gleich einem anderen ist. In den Streams stände da z.B. für einen Vergleich

if (traits_type::eq(character, other_character))

Genauso werden dort auch Typen definiert - wie int_type, und eof.
Arcoths Code leitet nun einfach einen eigenen Streambuf von std::streambuf ab und überschreibt overflow. Ist das übergebene Zeichen nicht eof - überprüft mit der Funktion traits_type::eq_int_type, die zwei int_types miteiander vergleicht, wird es nach std::cout geschrieben. Dazu wird rdbuf aufgerufen, was einene Zeiger auf den internen Streambuffer von std::cout zurückliefert. Dort wird das schon oben erwähnte sputc aufgerufen. sputc will jedoch einen char_type, weswegen das erst mit traits_type::to_char_type konvertiert wird. Das Ergebnis davon wird einfach zurückgegeben.
In der main wird lediglich ein std::ostream erstellt, der diesen Streambuffer nutzt.

]]>https://www.c-plusplus.net/forum/post/2397351https://www.c-plusplus.net/forum/post/2397351Sun, 04 May 2014 17:26:23 GMT<![CDATA[Reply to Mein eigenes Streamobjekt? on Sun, 04 May 2014 17:40:16 GMT]]>

Man müsste also mit uint32_t arbeiten, anstatt mit char.

Nicht ganz: Mit wchar_t oder - seit C++11 - char32_t .

]]>https://www.c-plusplus.net/forum/post/2397352https://www.c-plusplus.net/forum/post/2397352Sun, 04 May 2014 17:40:16 GMT<![CDATA[Reply to Mein eigenes Streamobjekt? on Sun, 04 May 2014 17:45:34 GMT]]>Danke für die ausführliche Erklärung, das muss ich jetzt erst einmal verdauen^^

]]>https://www.c-plusplus.net/forum/post/2397353https://www.c-plusplus.net/forum/post/2397353Sun, 04 May 2014 17:45:34 GMT<![CDATA[Reply to Mein eigenes Streamobjekt? on Sun, 04 May 2014 18:17:43 GMT]]>Arcoth schrieb:

Man müsste also mit uint32_t arbeiten, anstatt mit char.

Nicht ganz: Mit wchar_t oder - seit C++11 - char32_t .

Ah, verdammt. War am Überlegen wie das Ding hieß und zu faul nachzugucken.

]]>https://www.c-plusplus.net/forum/post/2397357https://www.c-plusplus.net/forum/post/2397357Sun, 04 May 2014 18:17:43 GMT