ostreamproblem

ich habe den referenzoperator auf der anderen seite
nee mal im ernst er hatte return vergessen. auch sei darauf zu achten das es diese funktion als friend in der klasse deklariert hat.

Spacelord

Blind muss man sein....

MfG Spacelord

Danke für den Tipp... hat aber leider noch nix geändert:

[C++ Error] Main.cpp(16): E2080 'myclass::operator <<(_STL::ostream &,const myclass &)' must be declared with one parameter

finix

Versuch's mal so:

class myclass
{
// ...
// ggf den op<< als friend deklarieren
};

std::ostream& operator<<(std::ostream &os, const myclass& a_member)
{
  os << a_member.name;
  return os;
}

phw

hast du einen prototyp von dem operator in myclass?
wenn ja, mach den mal weg.

also:

myclass{
//...
//ostream& operator<<(ostream&,myclass&) <-- auskommentieren!
//...
};

ostream& operator<<(ostream& os,myclass& t){
    return os<<t.name;
}

ich habe genau das gleiche Problem...hab es schon in verschiedenen Varianten Probiert, wie ihr oben vorgeschlagen habt...immer der selbe fehler!

Was meinst du mit Prototyp?

Ich habe bisher
ostream operator<<... in die Klassendekleration geschrieben...jetzt hab ich's außerhalb geschrieben und da war der Fehler nicht mehr da...

aber ein neuer...

und zwar hab ich in der Klasse cout<<"..." geschrieben

ALs Fehlermeldung erscheint:
`cout' undeclared (first use this function)

woher kommt das auf einmal...war vorher nicht?

leech

wenn du kein "using namespace std;" hast, dann musst du vor daas cout ein "std::" schreiben...

#include <iostream> solltest du auch haben!

mit dem cout geht auf einmal wieder aber es ist ein neuer Fehler aufgetreten...

ostream operator<< (ostream& op, myclass& x)
              {
                      return op<<x.get()<<"\n"; //in dieser Zeile muss fehler sein
              };

es wird folgender Fehler angezeigt:

3 C:\c++\header.hpp 'In copy constructor `std::basic_ios<char, std::char_traits<char> >::basic_ios(const std::basic_ios<char, std::char_traits<char> >&)':

738 C:\Programme\Dev-Cpp\include\c++\3.4.2\bits\ios_base.h `std::ios_base::ios_base(const std::ios_base&)' is private

was soll das sein?

sieht so aus als ob der cout nicht kennt. setzt am besten mal std:: vor cout

#include <iostream>
#include <string>

class myclass {
		std::string name;

	public:
		myclass(std::string n) : name(n) {};
		~myclass(){};

                  //prototyp von operator<<
		friend std::ostream &operator<<(std::ostream &os,const myclass &a_member);
    };

std::ostream &operator <<(std::ostream &os,const myclass &a_member) 
	{
	return os<<a_member.name;
	};

ich gaube das duerfte jetzt verstaendlich sein.

@leech an using namspace std; lag es... trotzdem danke

Das Problem von meinem Vorletzten Threat ist trotzdem noch nicht gelöst, könnt ihr mir helfen? Bitte! Danke!

Danke an alle...es funktioniert...ich bin auch doof...
habe statt ostream& operator<<() nur ostream operator<<() geschrieben...jetzt geht alles.

schöner Sonntag!

mfg pfidu (Pferd im Dunkeln )

HumeSikkins

Hallo,
kleiner Típp: oft hilft es, wenn man einfach mal auf die Mitteilungen seines Compilers achtet. Die sind ja nicht primär dazu da einen zu ärgern sondern eigentlich als Hilfe gedacht. Es lohnt sich also sich in dieser Richtung ein wenig fortzubilden. Dazu gehört u.A, dass man die Fachbegriffe lernt, die bei der C++ Programmierung eine Rolle spielen, da der Compiler genau diese verwendet wenn er mit uns kommuniziert.

Z.B.

C:\c++\header.hpp 'In copy constructor `std::basic_ios<char, std::char_traits<char> >::basic_ios(const std::basic_ios<char, std::char_traits<char> >&)':

738 C:\Programme\Dev-Cpp\include\c++\3.4.2\bits\ios_base.h `std::ios_base::ios_base(const std::ios_base&)' is private

Aha. Der Compiler teilt mit, dass der Copy-Ctor von ios_base private ist und das deshalb der Copy-Ctor von basic_ios nicht aufgerufen werden kann.
Leider versäumt der Compiler es hier den gesamten Instanziierungskontext zu nennen. Dafür teilt er die Zeilennummer mit, in der das Problem aufritt.
Nun müssen wir nur noch die folgenden zwei Fragen klären und schon ist das Problem gelöst:
1. In welcher Beziehung stehen basic_ios, ios_base und die genannte Zeile?
2. Wann wird ein Copy-Ctor aufgerufen?

Für die Beantwortung von 1. konsultiert man am Besten eine beliebige C++ Referenz. Nach kurzem lesen stellt man fest, dass es sich bei basic_ios und ios_base um Basisklassen von ostream handelt. Wir wissen also schonmal, dass irgendwas in der Verwendung von op den fehlerhaften Aufruf des Copy-Ctors verursacht.

Wann wird ein Copy-Ctor aufgerufen? Das weiß man entweder aus dem Kopf oder aber man konsultiert ein beliebiges C++ Einsteigerbuch. Im letzteren Fall braucht man etwa 10 Minuten um herauszufinden, dass der einzige Kontext in dem ein Copy-Ctor aufgerufen wird der hier in Frage kommt die by-value-Rückgabe ist.

Zusammengefasst:
a) Der Copy-Ctor von ostream ist nicht aufrufbar.
b) Die by-value-Rückgabe erfordert aber einen Copy-Ctor.

Mögliche Lösungen:
1. Wir machen den Copy-Ctor von ostream aufrufbar
2. Wir verzichten auf die by-value-Rückgabe.

1. ist keine gute Idee.
Bleibt 2. und damit z.B. die Möglichkeit op per Referenz zurückzuliefern.

ostream& operator<< (ostream& op, myclass& x)
{
   return op<<x.get()<<"\n";
}