#include <strstream> 
#include <iostream>

using namespace std;

class myStream	:	public ostrstream
{ 
public: 
	myStream() : ostrstream()			{} 
	friend myStream& my(myStream& ml)	{	ml << "<myStream>";	return ml;	} 
}; 

// manipulator function 
inline myStream& operator<<(myStream& ml, myStream& (*function)(myStream&) ) 
{	return (*function)(ml);	} 

int main() 
{
	myStream MyStream; 

	my(MyStream);
	MyStream << my;					//	!!! hier der Fehler in gcc. my was not declared in this scope
	MyStream << my << my << "hallo1";
	MyStream << "hallo2" << my;		//	!!! hier der Fehler in VC2008. Für my wird die Adresse ausgegeben
	MyStream << ends;

	cout << MyStream.str();
}

bin für jeden Tip dankbar.
tschüß
Troll.Soft

vor die Klassendefinition von myStream, und gut ist.
Dann kompiliert es auch unter Linux, führt dann aber in Zeile 26 nicht die Funktion aus - warum?

ostream& operator<<(ostream& stream, const char*);

existiert und gibt keinen myStream zurück. Deshalb kommt der nächste "<< my" nicht in ein myStream sondern ein stinknormales ostream. Und dafür existiert deine Operatorüberladung nicht.
Warum denn eigentlich ableiten? Ist hier (bisher) absolut unnötig. Was hast du noch alles vor?

#include <strstream> 
#include <iostream>

using namespace std;

class myStream	:	public ostrstream
{ 
public: 
	myStream() : ostrstream()			{} 
}; 

inline myStream& my(myStream& ml) 
{	ml << "<myStream>";	return ml;	} 

// manipulator function 
inline myStream& operator<<(myStream& ml, myStream& (*function)(myStream&) ) 
{	return (*function)(ml);	} 

int main() 
{
	myStream MyStream; 

	my(MyStream);
	MyStream << my;					
	MyStream << my << my << " hallo1 ";
	MyStream << " hallo2 " << my << " Ende ";		//	!!! hier der Fehler. Für my wird die Adresse ausgegeben
	MyStream << ends;

	cout << MyStream.str();
}

class myStream;
myStream& my(myStream&);

vor die Klassendefinition von myStream, und gut ist.
Dann kompiliert es auch unter Linux, führt dann aber in Zeile 26 nicht die Funktion aus - warum?

ostream& operator<<(ostream& stream, const char*);

existiert und gibt keinen myStream zurück. Deshalb kommt der nächste "<< my" nicht in ein myStream sondern ein stinknormales ostream. Und dafür existiert deine Operatorüberladung nicht.
Warum denn eigentlich ableiten? Ist hier (bisher) absolut unnötig. Was hast du noch alles vor?

Werde ich auch noch machen.
Warum ableiten? Weil die Klasse noch ein wenig mehr kann, als im eingedampften Code zu sehen ist. Es werden eigene Variable gehalten und noch weitere Klassen abgeleitet. 90% funktioniert auch schon.

tschüß
Troll.Soft

habe ich gemacht.
Ergebnis: Alles compiliert auch unter gcc, allerdings wird immer noch die Adresse der Funktion ausgegeben.

Und auch dazu hab ich was geschrieben...

Troll.Soft schrieb:

habe ich gemacht.
Ergebnis: Alles compiliert auch unter gcc, allerdings wird immer noch die Adresse der Funktion ausgegeben.

Und auch dazu hab ich was geschrieben...

Und das habe ich nun auch eingearbeitet.
Ergebnis: Der Code läuft unter VC2008 und gcc so wie es gedacht ist.

Vielen Dank für die schnelle Hilfe.
Jetzt muß ich mich um den original-code kümmern.

tschüß Troll.Soft

P.S.: kann ich hier irgendwo den Status gelöst setzen?

#include <strstream> 
#include <iostream>

using namespace std;

class myStream; 
myStream& my(myStream&);

class myStream	:	public ostrstream
{ 
public: 
	myStream() : ostrstream()			{} 
	friend myStream& my(myStream& ml)	{	ml << "<myStream>";	return ml;	} 
}; 

myStream& operator<<(myStream& stream, const char* S)	{	(ostrstream&)stream << S;	return stream;	} 

// manipulator function 
inline myStream& operator<<(myStream& ml, myStream& (*function)(myStream&) ) 
{	return (*function)(ml);	} 

int main() 
{
	myStream MyStream; 

	my(MyStream);
	MyStream << my;				
	MyStream << my << my << " hallo1 ";
	MyStream << " hallo2 " << my << " hallo " << my << " hallo " << my;	
	MyStream << ends;

	cout << MyStream.str();
}

Zeiger auf Member-Funktionen sind ne böse Sache.

Wieso

Janjan schrieb:

Zeiger auf Member-Funktionen sind ne böse Sache.

Wieso

Missverständlich formuliert. Nicht böse im Sinne von "nicht nutzen!", sondern böse im Sinne von ärgerlich zu nutzen.

P.S.: kann ich hier irgendwo den Status gelöst setzen?

Ja. Dein erstes Posting editieren und dem Titel ein [gelöst] hinzufügen.

Und das habe ich nun auch eingearbeitet.
Ergebnis: Der Code läuft unter VC2008 und gcc so wie es gedacht ist.

Und dir ist auch klar, dass das nur solange gut geht, wie du nicht auch plötzlich andere Typen ausgeben willst. int, std::string, eigene Klassen, die nur die Überladung für den ostream& anbieten...
Deshalb nochmal die Frage: Warum denkst du musst du von ostrstream ableiten?

Und dir ist auch klar, dass das nur solange gut geht, wie du nicht auch plötzlich andere Typen ausgeben willst. int, std::string, eigene Klassen, die nur die Überladung für den ostream& anbieten...
Deshalb nochmal die Frage: Warum denkst du musst du von ostrstream ableiten?

Einige Probleme sind mir schon klar, andere vermutlich noch nicht Diese anderen werden sich noch rechtzeitig durch Abstürze etc bemerkbar machen.

Von ostrstream ableiten erscheint mir der natürliche Weg. Falls das sich als Fehlschlag erweist habe ich keine Hemmungen eine eigene Klasse ohne abzuleiten zu erstellen.

Einzig wichtig ist: Es läuft mit allen Compilern und der Stream spuckt aus, was er soll.

tschüß
Troll.Soft

Grüssli

Kleine Anmerkung:
ostrstream ist deprecated, somit veraltet und sollte nicht mehr verwendet werden.

Grüssli

wird berücksichtigt