Suche eine ausführliche Doku zur ostream Klasse

[SirLant]

Den habe ich von dort,
naja es soll ja nur die Oberfläche so sein wie ostream, möchte das ganze, dann
nicht nur auf der Konsole ausgeben können, sondern auch z.B. in einem Fenster,
oder einer Datei, je nachdem was für ein Objekt ich dem ctor gebe.

[Shade Of Mine]

Was hindert dich daran es so wie Josuttis zu machen? Denn so ist es richtig!

Die scheinen dort einen Fehler gemacht zu haben, beim gcc ist es nämlich ne by value übergabe (schau mal bei dir in die ostream Datei)

[SirLant]

Stimmt bei mir sind die auch by val übergeben.

Habe zu Josuttis Code ne Frage, er schreibt den Code ja auf/in diesen File Descriptor,
aber was ist ein Filedescrpitor? Im Beispiel ruft er den ctor einfach mit einer 1 auf

[Shade Of Mine]

zB open() liefert einen Filedescriptor

es ist eine Zahl die ein File identifiziert - welche Zahl das ist, interessiert dabei nicht. open liefert dir eine passende zahl...

[SirLant]

Da ich nicht imstande war eine Klasse wie Josuttis' Klasse aufzubauen, welche
auf ein beliebiges Gerät Daten ausgibt, habe ich mir jetzt eine eigene Schnittstelle
gebastelt, die so viele Gemeinsamkeiten mit der echten hat, wie möglich und vor
allem noch sinnvoll sind.
Es existiert bisher aber nur die öffentliche Schnittstelle, aber genau um die gehts
ja auch

Es gibt sicher auch ne Möglichkeit iostream zu benutzen, aber dazu reicht mein
Wissen derzeit noch nicht aus und deshalb habe ich es so gelöst wie es für mich
möglich war.

Gibt es Bücher die sich mit der ganzen Bibliothek befassen und nicht nur deren
Benutzung erörtern, sondern auch den internen Aufbau? Find es eigentlich ziemlich
interressant wie die aufgebaut ist, nur versteh ich den Aufbau nicht so wirklich,
liegt vllt. auch an den Namen die die verwendet haben

// External Output Functions
mostream& operator<< (mostream& os, char ch );
mostream& operator<< (mostream& os, signed char ch );
mostream& operator<< (mostream& os, unsigned char ch );

mostream& operator<< (mostream& os, const char* str );
mostream& operator<< (mostream& os, const signed char* str );
mostream& operator<< (mostream& os, const unsigned char* str );

class IMostreamDevice:

class mostream {

	public:

	// ctor

	// Constructs an Object of mostream, using the given IMostreamDevice
	// for output. If buffered is true mostream buffers the output in a
	// buffer with the length of buf_size.

	mostream (IMostreamDevice * od, bool buffered = true, size_t buf_size = 80);

	// dtor

	// Virtual destructor. No operation.

	virtual  ~ostream ();

	// Member Functions

	// A call to this member function forces the stream's 
	// buffer to syncronize its data with the content of the 
	// physical device associated with it.

	mostream & flush (void);

	// Inserts the character ch if output stream is ready, otherwise badbit is set.

	mostream&  put ( char ch );

	// Inserts into the output stream a sequence of characters starting by character
	// pointed by str and following by successive characters in the array until the number
	// of characters specified by n has been successfully written or until an error occurs 
	// in the output sequence. No check for ending null characters is done. 

	mostream&  write ( const char* str , size_t n );

	// The function returns true if the badbit stream's error flag has been set by a previous
	// i/o operation.

	bool bad ( ) const;

	// The function returns true if an error other than End-Of-File has occurred after an output
	// operation. The function checks if either badbit or failbit state flags are set in the 
	// stream, if so it returns true, otherwise false.

	bool fail ( ) const;

	// The function returns true if none of the stream's error flags are set.

	bool good ( ) const;

	// Overloaded Operatos

	mostream& operator<< (bool& val );
	mostream& operator<< (short& val );
	mostream& operator<< (unsigned short& val );
	mostream& operator<< (int& val );
	mostream& operator<< (unsigned int& val );
	mostream& operator<< (long& val );
	mostream& operator<< (unsigned long& val );
	mostream& operator<< (float& val );
	mostream& operator<< (double& val );
	mostream& operator<< (long double& val );

	// A stream derived from ios can be casted to a pointer. This pointer is null if any of the
	// error flags failbit or badbit is set.
	// Otherwise a non-zero pointer (not intended to be referenced - just to indicate success)
	// is returned. 

	operator void * ( ) const;

	// Returns true if any of the error flags failbit or badbit is set. Otherwise returns false.
  	// This behavior is equivalent to member function fail. 

	bool operator ! ( ) const; 

	protected: 

};

Was haltet ihr davon`? Bin für konstruktive Kritik offen

[Shade Of Mine]

SirLant schrieb:

Was haltet ihr davon`? Bin für konstruktive Kritik offen

ich kann zB nicht
myObject.serialize(dein_stream);
machen, weil dein_stream kein ostream ist.
ich kann nicht
getline(dein_stream, str);
machen...

Wie sieht es mit der Synchornisation eingabe/ausgabe aus?

Warum puffert der Stream und nicht der Streambuffer (der bei dir IMostreamDevice) heisst - denn schliesslich weiss ja nur er, wohin ausgegeben wird und kann somit optimal puffern...

Warum verwendest du keine exception? Wenn du schon die kompatibilitaet zu ostream aufgibst, dann mach das design wenigstens besser

Woran hapert es denn bei Josuttis' Variante?

[SirLant]

An Exceptions hab ich auch schon gedacht, soll ich dann Exceptions schmeißen statt
Funktionen wie goodbit und badbit usw. anzubieten wie es iostream tut?

Naja mir ist nicht klar, wie Josuttis' Variante z.B. auf nem von mir geschriebenen
Ausgabestrom Daten ausgeben kann.

Die Klasse von mir kann _nur_ Daten ausgeben, keine einlesen.
Ich dachte eigentlich, dass ich den Benutzer entscheiden lassen kann ob ein
Puffer verwendet wird und in welcher Größe und das wird dann an die Implementierung
von IMostreamDevice weitergereicht.

Ein getline gibt es daher nicht, und putline ist im Grunde unnötig, da man ja
die Daten mit einem einfachen myObj << "Tolle Zeile"; ausgeben kann.

[Shade Of Mine]

SirLant schrieb:

An Exceptions hab ich auch schon gedacht, soll ich dann Exceptions schmeißen statt
Funktionen wie goodbit und badbit usw. anzubieten wie es iostream tut?

Exakt. streams bieten d ja die schoene methode setexceptions() an

Naja mir ist nicht klar, wie Josuttis' Variante z.B. auf nem von mir geschriebenen
Ausgabestrom Daten ausgeben kann.

Jousstis verlang, dass man die Datei selber oeffnet - mit der Funktion open() und am ende wieder schliesst (mit close())

Das ist uU wichtig um den Code zu verstehen.

Im prinzip macht der Stream ansich dann ja nicht viel. Naemlich ausser dem Ctor garnix.

Die ganze Arbeit uebernehmen die streambuffer.

da gibt es overflow() und xsputn(), die die schreibarbeit uebernehmen.
und das war es dann ja auch schon.

Ich dachte eigentlich, dass ich den Benutzer entscheiden lassen kann ob ein
Puffer verwendet wird und in welcher Größe und das wird dann an die Implementierung
von IMostreamDevice weitergereicht.

OK, das ist akzeptabel. Ich dachte der stream ansich puffert dann.

die Daten mit einem einfachen myObj << "Tolle Zeile"; ausgeben kann.

mein myObj.writeAt(stream); funktioniert trotzdem immer noch nicht.

[SirLant]

für ein myObj.writeAt (stream) müsste ich ja nur eine Funktion anbieten, welche
ein istream Objekt übernehmen kann, oder?

[Shade Of Mine]

SirLant schrieb:

für ein myObj.writeAt (stream) müsste ich ja nur eine Funktion anbieten, welche
ein istream Objekt übernehmen kann, oder?

Ich meinte damit im Prinzip - dass garkeine bestehende Funktion mit deinem stream umgehen kann:

stream<<string("hallo");
geht zB auch nicht.

denn alle streams sind entweder istream oder ostream (oder manchmal auch beide). dein stream ist etwas anderes - ich kann deshalb meine ueberladenen operatoren (<<) nicht verwenden, sondern muesste sie nochmal ueberladen.

und genau das macht deine klasse leider relativ sinnlos. es ist zwar logisch gesehen ein stream, aber fuer den compiler eben nicht (keine IS-A beziehung)

[SirLant]

Das wird sie nicht können, du könntest aber einfach mostream cout (outputObj);
schreiben, dann die Daten ausgeben und später diese Zeile löschen, und das normale
cout benutzen.
Das war eigentlich mein Ziel.

Ich werde nacher wenn ich Zeit habe die Exceptions einbauen und noch ein zwei
Änderungen vornehmen und dir nochmal zeigen, besonders bei den Exceptions werd
ich deinen (euren :)) Rat brauchen, habe bisher noch nie damit gearbeitet.

[Shade Of Mine]

SirLant schrieb:

Das wird sie nicht können, du könntest aber einfach mostream cout (outputObj);

mostream cout (outputObj)
string s("hello world");
cout<<s;

[SirLant]

Hm... was unterstützt denn alles die streams, könnte für diese ja eine Funktion
hinzufügen.

[Shade Of Mine]

SirLant schrieb:

Hm... was unterstützt denn alles die streams, könnte für diese ja eine Funktion
hinzufügen.

du hast meine postings nicht verstanden oder?
_jede_ Klasse kann einen op<< haben und _keiner_ wird bei dir funktionieren.

sicher für string lässt sich einer schreiben, aber gehen wir weiter: es gibt unendlich viele Klassen und das stream Konzept ist eben dafür da, dass sich jedes Objekt auf jeden stream ausgeben kann - indem eben ostream als interface (wenn man so will) verwendet wird. deine klasse macht das nicht, deswegen kann man sie nicht mit bestehenden klassen verwenden.

der aufwand es nochmal richtig zu machen wäre sicher geringer als für alle möglichen typen einen op<< zu implementieren (abgesehen von der zeit die du für die ganzen features brauchst, die ostream dir ja frei haus liefert).

[SirLant]

Hm dann wir das ganze um einiges schwieriger für mich, muss mich dann wohl nochmal
reinknien und schauen ob ich es hinbekomme

Danke