T& rO = O; // laut Buch wird hier der Zuweisungsoperator von T aufgerufen .

Das ist Blödsinn.

Selbst wenn rO keine Referenz wäre, würde hier nicht der Zuweisungsoperator aufgerufen. Vermutlich ist das Buch nicht so gut. Welches ist es denn?

Hallo,
lerne grade C++ mithilfe eines Buchs.
In dem Buch kommt folgendes Beispiel vor:
T O ;
T& rO = O; // laut Buch wird hier der Zuweisungsoperator von T aufgerufen .
Jetzt bin ich verwirrt.............

Wenn das so im Buch steht, scheint es ein schlechtes Buch zu sein, da die Aussage falsch ist.

Toman schrieb:

Wird bei Definition einer Referenz mit einem Objekt nicht einfach dessen Adresse bitweise kopiert,ähnlich einem speziellen konstanten Zeigern auf denen man komfortabler arbeiten kann ???

Richtig.

Gruß,
SP

Toman schrieb:

Wird bei Definition einer Referenz mit einem Objekt nicht einfach dessen Adresse bitweise kopiert,ähnlich einem speziellen konstanten Zeigern auf denen man komfortabler arbeiten kann ???

Richtig.

Nicht unbedingt richtig, weil im Standard nicht definiert ist wie der Compiler Referenzen zu implementieren hat. Wird aber in den meisten Fällen wohl so gemacht (mir ist zumindest kein Fall bekannt wo es anders ist).

//Klassendefinition
class Ober{
public:
//...
private:
int iO; //Daten der Klasse Ober
};

class Unter : public Ober{
public:
//...
private:
int iU; //Daten der Klasse Unter
};

//main() Programm:
Unter U1,U2;
U1=U2; //kein Problem: Unter::operator=(const Unter&)

//polymorphe Objekte(statischer != dynamischer Typ)
Ober& rO1 = U1;
Ober& rO2 = U2;

Falls der Zuweisungsoperator nicht virtuell ist, werden nur die statischen Typen betrachtet:

Ober O1;
Ober O2;
O1 = O2; // Ober::operator=(const Ober&) ok

Aus der Zuweisung

rO1 = U2; //Ober::operator=(const Unter&) ?

versucht der Compiler einen Zuweisungsoperator zu finden den es nicht gibt.
Das Ergebnis ist ein Fehlermeldung des Compilers................
------------------------------------------------------------------------------
Das mit der Subtyp-Polymorphie und der Virtualität zur eventuellen dyn. Bindung
von Operator-/Funktionsaufrufen ist mir klar,kenn ich aus anderen Sprachen(in Java wird ja jede Funktion per default dynamisch gebunden,wenn man das nicht durch Modifier verhindert) ,ABER...um auf das Besipiel zurück zu kommen :
Zunächst mal ist doch Ober& rO1 = U1 schon definiert , dachte auch , dass man das referenzierte Objekt dann nicht mehr ändern kann? OK, aber darüber hinweg sehend dann eben diese vermeindliche Zuweisung rO1 = U2 bei der dann angeblich der Zuweisungsoperator aufgerufen wird...???

Dachte hald der Zuweisungsoperator eines Objekts wird nur aufgerufen um dann in der Funktion (eine Teilmenge bei Subtyp)der Member des zu kopierenden Objekts in die eigenen davon existierenden Member zu kopieren also z.B. bei O1=O2 ,aber dass rO1 = U2 irgendwas mit dem in der Klasse definierten(oder dem default) Zuweisungsoperator zu tun haben soll kapier ich nicht.

Jetzt nach der genauen Angabe des Bespiels : Bleiben eure bisherigen Statements
zu rO1 = U2 bestehen oder ändert sich dadurch was ? Dachte jedenfalls hier
würde eine Referenz angelegt,also eine Adresse kopiert und nicht der Zuweisungsoperator aufgerufen........

@MFK : wenn es keine Definition einer Referenz wär sondern die Def eines Objekts
bei gleichzeiteiger "Zuweisung" eines (nicht temporären) Objekts würde
der CopyKonstruktor des neu zu def. Objekts aufgerufen...Ist es das was
du damit sagen wolltest ,oder weiß ich schon wieder was nicht ?

Danke für eure Hilfe überigens und liebe Grüße

So ein kompliziertes Beispiel brauchst Du auch erst gar nicht betrachten, wenn Du Referenzen noch nicht 100%ig verstanden hast. Probier es erstmal hiermit:

int main() {
    int i = 1;
    int j = 3;
    int& k = i;
    k = j;
    i = 23;
    j = 42;
    cout << k << '\n';  
  }

Gruß,
SP

rO1 = U2;

eine Fehlermeldung des Compilers provoziert. So ein Käse.

Was dort NICHT steht, ist das, was Du im ersten Beitrag geschrieben hast. Es sieht so aus, als ob Du Zuweisung mit Initialisierung von Referenzen durcheinander bringst. Folgend ein Vergleich mit Zeigern. Beide Seiten machen in etwa das gleiche:

// Zeiger            Referenz

   T* pO = &O;       T& rO = O;
   *pO = X;          rO = X;
   pO = &Z;          Es gibt kein Äquivalent

Man kann sich eine Referenz wie einen Zeiger vorstellen. Der Unterschied: Beim Initialisieren braucht man nicht den Adress-Operator (&) und die Dereferenzierung ist danach implizit. Deswegen kann man auch die Referenz auch nicht mehr verändern. In beiden Versionen würde nur die zweite Zeile den Zuweisungsoperator der Klasse aufrufen. Die erste Zeile ist jeweils eine Initialisierung. Von einer Zuweisung spricht man nur dann, wenn es das Objekt schon gibt. Die folgenden zwei Zeilen sind auch Initialisierungen

string s = "hello";
   string t = s;

Hier wird nirgens string::operator= aufgerufen -- höchstens der Kopier-Konstruktor.

Gruß,
SP

Ist aber wohl ein riesiger Bock den er da geschossen hat. Und das in der 9. Auflage des Buches und in dem als Leseprobe veröffentlichen Kapitel. Katastrophe!

Habe zwar bisher nur Gutes über das Buch gehört, aber das hier verleitet mich doch dazu es nicht mehr als Empfehlung aufzuzählen. Was soll's, der Primer ist sowieso besser.