Linker Error C2679:

"Binärer Operator 'Operator' : Kein Operator definiert, der einen rechtsseitigen Operator vom Typ 'Typ' akzeptiert (oder keine geeignete Konvertierung möglich)"

Ich erhalte den Fehler bei folgendem Fall. Eine Klasse (Foo) implementiert den Operator "<<" wie folgt:

// Operatoren
std::ostream & operator << (const char *pstr) { return std::cout << pstr; }
std::ostream & operator << (std::ostream &os) { return std::cout << os; }
std::ostream & operator << (int n)            { return std::cout << n; }

Nun möchte ich folgendes Aufrufen:

Foo << std::endl;

Das führt zu oben genanntem Fehler. Bei

Foo << "" << std::endl;

tritt kein Fehler auf.

Mir ist nicht klar warum der Linker hier einen Fehler meldet. Könnte mir das jemand erklären?

PS: Das ist übrigens kein Linker-Error, sondern ein Compiler-Error (linker-Fehler beginnen mit LNK).

PPS: Was willst du mit der Klasse denn erreichen?

ganz einfach - endl ist kein char* oder ähnliches, sondern ein Manipulator (typischerweise ist das eine Funktion, die einen ostream erhält - und ostream::operator<< ist so überladen, daß er diese Funktion aufruft). Das heißt, daß keiner deiner Operatoren in der Lage ist, endl als Parameter zu übernehmen.

Also "endl" ist laut MSDN als Manipulator definiert und eine Memberfunktion von basic_ostream. Wie muss ich meinen Operator "<<" überladen um

Foo << std::endl

nutzen zu können? Finde ich schwer ersichtlich aus der MSDN.

CStoll schrieb:

PS: Das ist übrigens kein Linker-Error, sondern ein Compiler-Error (linker-Fehler beginnen mit LNK).

Nein natürlich. Sonst würde auch wohl kaum ein C vor der Fehlernummer stehen. *schäm*

CStoll schrieb:

PPS: Was willst du mit der Klasse denn erreichen?

Ich beziehe es mal auf dem Operator "<<". Ich brauche für ein Projekt eine Klasse die Daten verarbeitet und ausgibt und um alles über diese Klasse laufen zu lassen habe ich den Operator "<<" mal überladen.

LordJaxom schrieb:

Ob es soviel Sinn macht einen ostream in einen ostream zu streamen, wage ich auch mal zu bewzeifeln...

Naja an sich keinen. Ich dachte aber erst das ich

Foo << std::endl

damit erschlagen kann.

template<typename T>
Foo& operator<<(const T& val) { cout<<val; return *this; }

(das schluckt alles, was auch cout aufnehmen könnte)

Alternativ kannst du dich ja durch die iostream-Header durchkämpfen und nachschlagen, wie endl genau definiert ist

Wenn du sowieso nur alles an cout weiterleitest, warum machst du kein Template draus?

Das ist eine sehr berechtigte Frage. Weil ich derzeit lediglich zur Ausgabenprüfung /-verarbeitung konstante Zeiger vom Typ char und Zahlen vom Typ int verwende bzw. es provisorisch erst nur so gelöst habe. Komforttechnisch würde es sich natürlich anbieten.

oder klar:

template<typename T>
Foo& operator<<(const T& val) { cout<<val; return *this; }

(das schluckt alles, was auch cout aufnehmen könnte)

Bis auf std::endl;

CStoll schrieb:

Alternativ kannst du dich ja durch die iostream-Header durchkämpfen und nachschlagen, wie endl genau definiert ist

Tja, das wollte ich ursprünglich vermeiden. Naja los gehts...

CStoll schrieb:

oder klar:

template<typename T>
Foo& operator<<(const T& val) { cout<<val; return *this; }

(das schluckt alles, was auch cout aufnehmen könnte)

Bis auf std::endl;

echt? in dem Fall bleibt dir nur die genauerer Suche - oder du schreibst statt endl halt "\n" raus, sollte in den meisten Fällen auch reichen.

PS: Was ist mit folgendem?

Foo::operator ostream&() { return cout; }

echt? in dem Fall bleibt dir nur die genauerer Suche - oder du schreibst statt endl halt "\n" raus, sollte in den meisten Fällen auch reichen.

Ich habe nicht brauchbares in den Headern finden können. In der MSDN ist der Operator mit folgenden Überladungen angegeben.

ostream& operator <<( ostream& (*fcn)(ostream&) );
ostream& operator <<( ios& (*fcn)(ios&) );

Damit kann ich aber nichts anfangen. Was für ein Funktionsparameter wird hier erwartet? Eine Referenz einer Referenz gecastet auf einen Zeiger vom Typ Funktion?

CStoll schrieb:

PS: Was ist mit folgendem?

Foo::operator ostream&() { return cout; }

Hier verstehe ich den Sinn gerade nicht.
Also das meine Klasse impliziet auf ostream& gecastet wird, wozu?

Habe nun eine Funktion namens endl implementiert

std::ostream & endl (void) { return std::cout << std::endl; }

Das gefällt mir aber überhaupt nicht.

ostream& operator <<( ostream& (*fcn)(ostream&) );
ostream& operator <<( ios& (*fcn)(ios&) );

Damit kann ich aber nichts anfangen. Was für ein Funktionsparameter wird hier erwartet? Eine Referenz einer Referenz gecastet auf einen Zeiger vom Typ Funktion?

Das ist ein Funktionszeiger, von einer Funktion die ostream& als Parameter übernimmt und ostream& zurückgibt. Vermutlich tut der operator<< von ostream nichts anderes als genau diese Funktion mit this aufzurufen:

ostream& operator<<(ostream& (*fcn)(ostream&))
{
  return fcn(*this);
}

Aber ob man sich auf all das verlassen sollte, ist die nächste Frage (Stichwort Implementationsabhängigkeit)

ostream& operator<<(ostream& (*fcn)(ostream&))
{
  return fcn(*this);
}

Aber ob man sich auf all das verlassen sollte, ist die nächste Frage (Stichwort Implementationsabhängigkeit)

Habe es jetzt so gelöst:

std::ostream & operator <<(std::ostream& (*fcn)(std::ostream&)) { return std::cout << *fcn;  }

Sicher sollte es doch eigentlich sein. Ich werde es warscheinlich nur nicht mit dem G++ auf einem Linuxsystem kompilieren können, denn fcn ist ja sicher nicht in der STL definiert. Gleich mal schaun.

(Was kommt eigentlich raus wenn man einen Funktionspointer dereferenziert? Ich habe bisher immer nur die Funktion dahinter ausgeführt )

Korrekt wär IMHO return fcn(cout);

Ach und fcn hat an der Stelle wenig mit der STL zu tun, innerhalb Deiner eigenen Funktion kannst du "fcn" auch "klausdieter" nennen

Und das geht durch den Compiler?

(Was kommt eigentlich raus wenn man einen Funktionspointer dereferenziert? Ich habe bisher immer nur die Funktion dahinter ausgeführt )

Korrekt wär IMHO return fcn(cout);

Ach und fcn hat an der Stelle wenig mit der STL zu tun, innerhalb Deiner eigenen Funktion kannst du "fcn" auch "klausdieter" nennen

Hmpf. Nun hat es klick gemacht. Ich konnte mit der Funktionssignatur nicht ganz so viel anfangen, da ich es immer anders gemacht habe. Um solche Konstrukte übersichtlich zu halten nutze ich meist typedef.

typedef void (__cdecl * fptr ) (void);
void test(fptr);

Nun ist es eigentlich klar. Und es muss fcn(cout) heißen.

Spitze. Vielen Dank an Euch.