mal eine naive Frage: Warum kann ich denn keine Referenz auf eigene Objekte direkt über std::out ausgeben?

Also Bsp.:

// Pseudocode Beispiel
class MyClass {
...
};

...
void OtherClass::test(MyClass& myClass)
{
    std::cout "MyClass: " << myClass << std::endl:
}

Das gibt nen Compilerfehler:

error: no match for 'operator<<' in 'std::operator<< [with _Traits = std::char_traits<char>](((std::basic_ostream<char, std::char_traits<char> >&)(& std::cout)), ((const char*)"MyClass: ")) << myClass'

Denke mal, dass dies nur mit Basistypen (wie z.B. int) geht, oder solchen Klassen, die mit dem <<-Operator von std::out klarkommen, oder?
Muss ich hier die Adresse von myClass nehmen, also &myClass? Oder eine andere Methode von std?

Vielen Dank schon einmal!

Ciao

std::ostream& operator << (std::ostream& out, const MyClass& data) {
    // ...
    // Einzelne Attribute von data ausgeben
    // ...

    // Referenz auf Ausgabestream zurückgeben (ermöglicht die Verkettung von <<)
    return out;
}

Was ist denn das Vorgehen, wenn ich prüfen möchte, ob das Objekt, das durch die Referenz repräsentiert wird das gleich ist, wie z.B. in der aufrufenden Methode? Gebe ich dann die Adresse der Referenz aus (also im Bsp. &myClass)?

Hintergrund ist, dass ich aufgrund von Refactoring nun Referenzvariablen in einer abstrakten Basisklasse habe, die beim Aufruf des Konstrukturs der abgeleiteten Klasse initialiisert werden (der Konstruktor der abgleiteten Klasse erhält 2 Referenzparameter und übergibt die dem Konstruktor der Basisklasse). Die Referenzvariablen der Basisklasse sind protected, so dass ich davon ausgehe, dass sie in Methoden der abgleiteten Klasse mit den im Konstruktor übergebenen Werten zur Verfügung stehen. Nun will ich prüfen, ob hier mein Denkfehler liegt und nun in der Basisklasse Referenzen auf die Referenz bestehen!

Was ist denn das Vorgehen, wenn ich prüfen möchte, ob das Objekt, das durch die Referenz repräsentiert wird das gleich ist, wie z.B. in der aufrufenden Methode? Gebe ich dann die Adresse der Referenz aus (also im Bsp. &myClass)?

Nachdem, was ich gelesen habe, heißt gleich für dich, gleicher Speicherbereich.

Leider muss das bei Mehrfachvererbung (ich weiß nicht ob anders auch) nicht
zwangsläufig der Fall sein:

#include <iostream>
#include <string>
class A{
int i;
};
class B{
int j;
};
class C : public A, public B{};
int main()
{
        C c;
        A& aRef = c;
        B& bRef = c;
        C& cRef = c;
        std::cout << &aRef << std::endl;
        std::cout << &bRef << std::endl;
        std::cout << &cRef << std::endl;
}

0xbffff9cc
0xbffff9d0
0xbffff9cc

Du kannst sogar Beispiele konstruieren, wo eine Referenz des gleichen Typs nicht
zwangsläufig die gleiche Adresse hat, weil ein Objekt doppelt davon erbt.

#include <iostream>
#include <string>
class A{
int i;
};
class B : public A{
};
class C : public A{
};
class D : public B, public C{};
int main()
{
        D d;
        C& cRef = d;
        B& bRef = d;
        A& a1Ref = cRef;
        A& a2Ref = bRef;
        std::cout << &a1Ref << std::endl;
        std::cout << &a2Ref << std::endl;
}

0xbffff9cc
0xbffff9c8

Falls du allerdings immer(!!!) virtuell (oder nicht doppelt) von dieser Klasse erbst, kriegst du
(glaub ich) immer die gleiche Speicheradresse bei Verwendung einer Referenz
auf diese virtuell geerbte Klasse.

#include <iostream>
#include <string>
class A{
int i;
};
class B : virtual public A{
};
class C : virtual public A{
};
class D : public B, public C{};
int main()
{
        D d;
        C& cRef = d;
        B& bRef = d;
        A& a1Ref = cRef;
        A& a2Ref = bRef;
        std::cout << &a1Ref << std::endl;
        std::cout << &a2Ref << std::endl;
}

0xbffff9cc
0xbffff9cc

Bei einfachen Vererbungsketten (keine Mehrfachvererbung) brauchen die
Typen der Referenzen (bei vermutlich vielen Compilern) nichtmal gleich sein.

#include <iostream>
#include <string>
class A{
int i;
};
class B : public A{
int j;
};
class C : public B{
int k;
};
int main()
{
        C c;
        A& aRef = c;
        B& bRef = c;
        C& cRef = c;
        std::cout << &aRef << std::endl;
        std::cout << &bRef << std::endl;
        std::cout << &cRef << std::endl;
}

0xbffff9c8
0xbffff9c8
0xbffff9c8

Zu debug-Zwecken reicht aber eine einfache Ausgabe der Speicheradresse auf
gleichen Referenztypen basierend, häufig aus.

Bevor jetzt Beschwerden kommen, dass der Standard das aber nicht garantiert:
-> Es sind nur praktische Hinweise, die wohl (vermutlich) auf einen Großteil
der Compiler zutreffen

Gruß,
CSpille

Unter Java ist dies sehr einfach, man gibt einfach das Objekt selbst aus, dann wird automatisch dessen eindeutige ID rausgeschrieben:

// Pseudocode
...
MyObject o1 = new MyObject();

System.out.println(o1);

mal eine naive Frage: Warum kann ich denn keine Referenz auf eigene Objekte direkt über std::out ausgeben?

Das hängt damit zusammen, daß wenn Du eine Referenz aufrufst, sich das ganze so verhält, als hättest Du den Wert direkt aufgerufen:

MyObject o;

cout << o;
// Geht logischerweise nicht.

MyObject &r = o;

cout << r;
// Das gleiche in grün, deshalb geht es auch nicht.

Um es mal mit Zeigern zu vergleichen:

MyObject *p = &o;

cout << p;
// Geht natürlich, weil er nur eine Adresse ausgibt.
// Aber:
cout << r;
// würde eher dem Aufruf
cout << *p;
// entsprechen, was wiederum
cout << o;
// entspricht.
// Und daß das nicht geht, dürfte einleuchten.

Alles klar?

Denke schon.
Nach meinem Verständnis eurer Antworten geht das deshalb nicht, weil ostream bzw. der <<-Operator nicht wissen, wie sie mit dem Wert eines Objektes (also nicht seiner Speicheradresse) umgehen sollen.
Daher auch der Hinweis von daersc, dass man den Operator überladen müsste.
Dieses Überladen würde man dann in seiner eigenen Klasse machen, oder?

Dieses Überladen würde man dann in seiner eigenen Klasse machen, oder?

Entweder in der Klasse selbst oder als globale Funktion.

Dieses Überladen würde man dann in seiner eigenen Klasse machen, oder?

Nein, das muss man in einer freien Funktion machen, denn es wäre ja wenn überhaupt eine Klassenmethode eine Methode von std::ostream und da kommst du nicht ran. Daher als freie Funktion. Siehe auch hier:
http://www.c-plusplus.net/forum/viewtopic-var-t-is-232010.html

Dieses Überladen würde man dann in seiner eigenen Klasse machen, oder?

Nein, der überladene Operator gehört ja zu ostream und nicht zu deiner Klasse.
Da man nicht im ostream-Header herumbasteln darf/sollte, definiert man ihn als globale Funktion.

Edit: könnte schwören, dass SeppJ's Beitrag zehn Sekunden vor dem Absenden noch nicht da war.

class myClass {
   // ... säckeweise private-Member...
public:
   virtual ostream& print(ostream&) const; // hat Zugriff auf Obige und wird weitervererbt
};

ostream& operator<<(ostream& ost, myClass const& m) { return m.print(ost); }

Gruß,

Simon2.

Edit: könnte schwören, dass SeppJ's Beitrag zehn Sekunden vor dem Absenden noch nicht da war.

Dann würde ich mich aber mal bei deinem Internet Provider beschweren,
wenn das Senden ca. 1,5 Minuten dauert

Mein Ping braucht ja schon fast 400ms, aber das ist schon etwas sehr heftig