Operator"<<"

[Drakos]

Hallo,
ich habe versucht den Operator << zu überladen bekomme aber die Fehlermeldung:
Binaerer Operator '<<' hat zu viele Parameter.

Was mach ich falsch?

der Header

#ifndef _TEST_H
#define _TEST_H

#include <string>
#include <ostream>

class Test
{
public:
	Test(std::ostream &p_Ostream);
	~Test();
	Test &operator<<(Test &p_Test, const std::string &p_strMsg);

private:
	std::ostream m_Ostream;

};	/// end of class

#endif	/// #ifndef _TEST_H

der Source

#include "Test.h"

Test::Test(std::ostream &p_Ostream) : m_Ostream(p_Ostream)
{
	;	/// nothing to do
}

Test::~Test()
{
	;	/// nothing to do
}

Test &Test::operator <<(Test &p_Test, const std::string &p_strMsg)
{
	std::string strTemp("Hallo ");
	strTemp += p_strMsg;

	p_Test.m_Ostream << strTemp;

	return p_Test;
}

das Hauptprogramm

#include "Test.h"

#include <iostream>

int main()
{
	Test test(std::cout);

	test << "Welt";

	return 0;
}

[Mirauder_Mo]

hallo,

du hast den operator zu einer memberfunktion gemacht, da hast du einmal einen typ Test(die instanz selbst) einmal ein Test das "übergeben" wir und dan den stream. wo neben den operator willst du das alles schreiben?

also entweder solte es keine memberfunktion sein, oder der test parameter muss weggelassen werden.

[alt]auserdem sollte nicht ein test zurückgegeben werden sonderen der stream, damit das kanze auch hintereinander funktioniert (z.b. cout<<test1<<test2;) dazu mus cout<<test1 einen stream zurueck geben.[/alt]

und zu näherem, ließ die tutorial oder die FAQ die bestimmt bald gepostet werden.

[edit] oh, hab mich da wohl etwas verkuckt in dem was du geschrieben hast, aber das mit der anzahl argumente bleibt. (sprich: nur ein operator) du benutzst also nicht p_Test.Ostream sondern this->Ostream (besser einfach nur Ostream)

[Jester]

Der operator<< sollte kein Member sein.

Sonst müßtest Du sowas schreiben:

Test t;
t << cout;

Das ist wohl...ähm... nicht intuitiv.
Das linke Argument sollte der ostream sein, das rechte der Typ den Du Ausgeben willst. Der Rückgabetyp sollte wieder ein ostream sein, damit wie oben schon beschrieben eine Kette gebildet werden kann.

cout << test1 << test2 << endl;

wird so ausgewertet:

((cout << test1) << test2) << endl;

da ist es günstig (lies erforderlich), wenn die Klammern jeweils zu einem Objekt vom Typ ostream ausgewertet werden.

Allgemein wird ein operator<< fast immer so aussehen:

ostream & operator<<(ostream & os, const Objekt & obj)
{
   // ...
   // hier das Objekt mit Hilfe von os ausgeben
   // ...
   return os;
}

[Drakos]

Ja das mag ja alles richtig sein, wenn ich möchte, dass Test mittels << auch in einen Stream ausgegeben wird. Das will ich aber nicht. Was ich will ist das was da steht. Deswegen soll es auch keinen Stream zurückgeben, da dann ein Hintereinanderschreiben, so wie ich es will, nicht mehr geht.

test << "foo" << "bar";

Also was ich will, ist, dass obiger Ausdruck funzt und der Stream ein Member ist.
Im Übrigen sollte es doch zu sehen sein, dass der Stream in den geschrieben wird, an den Konstruktor übergeben wird. Deshalb wird ein t<<cout; nicht wirklich Sinn machen.

[Bashar]

Jester: Seine Klasse ist ein Stream, und soll nicht ausgegeben werden. Von daher ist es schon nicht so verkehrt, operator<< als Member zu deklarieren.

[Jester]

Ups... bin schon ruhig.

[Erhard Henkes]

MSVC++6:
Compiler-Fehler C2804 - Binärer Operator 'Operator' hat zu viele Parameter

Der angegebene überladene binäre Operator wurde mit mehr als einem Parameter deklariert.

Ein Beispiel für diesen Fehler:

class X
{
   X operator+ ( X , X );  // Fehler, zwei Parameter
   X operator+ ( X );      // Korrekt, ein Parameter
};

Dev-C++:

'Test& Test::operator<<(Test&, const std::string&)' must take exactly one argument

Also nix mit zwei Formalparametern.

[Drakos]

Hmmm, danke für den Anstoss. Ich hatte das zwar schon mit einem Parameter probiert und da ging es nicht aber jetzt gehts!
Also danke.

[Erhard Henkes]

Zeig doch mal das funktionierende Programm.

[Drakos]

der Header

#ifndef _TEST_H
#define _TEST_H

#include <string>
#include <ostream>

class Test
{
public:
	Test(std::ostream &p_Ostream);
	~Test();

	std::string endl();

	Test &operator<<(const std::string &p_strMsg);

private:
	std::ostream m_Ostream;

};	/// end of class

#endif	/// #ifndef _TEST_H

der Source

#include "Test.h"

Test::Test(std::ostream &p_Ostream) : m_Ostream(p_Ostream)
{
	;	/// nothing to do
}

Test::~Test()
{
	;	/// nothing to do
}

std::string Test::endl()
{
	return "\n";
}

Test &Test::operator <<(const std::string &p_strMsg)
{
	std::string strTemp("Hallo ");
	strTemp += p_strMsg;

	m_Ostream << strTemp;

	return *this;
}

das Hauptprogramm

#include "Test.h"

#include <iostream>

int main()
{
	Test test(std::cout);

	test << "Welt";

	return 0;
}

[Erhard Henkes]

MSVC++6 schluckt dies problemlos.
Dev-C++ motzt.

[Drakos]

Was hat er denn der Gute Dev?