return (*this);

bedeutet das "gibt einen zeiger auf sich selbst zurück?"

wenn nein, was dann?

und wozu braucht man das?

habt ihr ein kleines beispiel für mich?

ne gibt entweder eine referenz oder eine copy zurück. je nach rückgabewert-deklaration.

rückgabewert is

reference&

... wie schaut der rückgabewert bei kopie aus? ist das denn der klassenname?

Artchi

Naja, *this als solches sollte man erklären: es dereferenziert this. Wenn du irgendwo einen Pointer hast, und du willst nicht die Adresse haben, sondern den Inhalt der Adresse, dann dereferenzierst du das, in dem du den Stern vor den Pointer stellst.

Ob return eine Kopie zurück gibt, ist ja dann eine ganz andere Geschichte. Kommt auf den Rückgabetyp drauf an.

und wann bzw. unter umständen muss man eine referenz zurückgeben,

wann ist sowas notwendig? habt ihr'n beispiel für mich? danke

godlikebot

class dolly
{
public:
    dolly clone()
    {
        return (*this);
    }
};

Bei Operator Überladung macht man das dauernd.

Artchi

peter k schrieb:

rückgabewert is

reference&

... wie schaut der rückgabewert bei kopie aus? ist das denn der klassenname?

klasse& foo(); // gibt ne Referenz zurück
klasse  foo();  // gibt ein Objekt zurück (in dem Fall ne Kopie)
klasse* foo();  // gibt ein Pointer zurück

Artchi

peter k schrieb:

und wann bzw. unter umständen muss man eine referenz zurückgeben,

wann ist sowas notwendig? habt ihr'n beispiel für mich? danke

Das kommt ja auf den Kontext an, wann du was wie zurück gibst. Das Kopien bei großen Objekten Performance kosten, sollte man aber halt wissen. Sollte man also nur dann zurück geben, wenn man es auch will (dann ist ja der Performance-Verlust nicht zu vermeiden).

Pointer und Refs gibt man halt zurück, wenn man das orig. Objekt zurück geben will.

Beispiele:

Wenn du zB den operator= für deine Klasse überlädst, um zB sowas woanders zu machen

MyClass a, b, c;
...
a=b;

Ruft dies a.operator=(b) auf...
Da bringt dir ja das return noch nichts, aber was ist wenn du

a = b = c

schreibst.
dann sieht das ja so aus:

a = b.operator=(c);

Und jetzt damit dein a was hat kommt das return *this ins spiel;
Weil es ja dann so aussieht:

a.operator=(b.operator=(c));

Jetzt siehst du ja wieso du this zurückgeben musst

Und operator könnte so aussehen:

MyClass& operator=(const MyClass& ob)
{
    // irgendwas gleichsetzen
    return *this;
}

Jetzt ne Frage an die Freaks:
Wenn ich ja nur

a = b;

dann wird ja trotzdem *this zurückgegeben. Hängt es dann da einfach in der Luft gibt es irgendwelche Verluste oder sonstiges ???

Pellaeon

das wird einfach nicht benutzt, Rückgabewerte muss man nicht annehmen

Danke,
ich habe jetzt irgedwie das komische Gefühl das ich das schonmal gefragt habe

yuhuuu, danke euch allen! hab's verstanden

MyClass& operator=(const MyClass& ob)
{
    if(this != &ob)  // nichts tun beim gleichen Objekt   <--- wichtig!
    {

    }

    return *this;
}

selbstzuweisung kann man auch anders abfangen, weiss grad nicht wie!!???

cu

operator= schreiben profis wie folgt:

// Now writing the assignment operator is super easy
Shape& Shape::operator=(const Shape& rhs)
{
    Shape temp(rhs);
    temp.Swap(*this);
    return *this;
}

volkard

............. schrieb:

operator= schreiben profis wie folgt:

// Now writing the assignment operator is super easy
Shape& Shape::operator=(const Shape& rhs)
{
    Shape temp(rhs);
    temp.Swap(*this);
    return *this;
}

oder machmal

// Now writing the assignment operator is super easy
Shape& Shape::operator=(Shape const& rhs)
{
    Shape tmp(rhs);
    Swap(tmp);
    return *this;
}

groovemaster

tokio schrieb:

if(this != &ob)  // nichts tun beim gleichen Objekt   <--- wichtig!

Das ist aber nicht der Normalfall. Selbstzuweisung abzufangen ist nur in sehr wenigen Fällen erforderlich. Korrekt aufgebaute Klassen können op= auch so problemlos handeln. Und dazu muss man nichtmal auf den swap Trick zurückgreifen.

wo liegt hier der unterschied?

Shape tmp(rhs); <-- locales objekt erstellen, copy constr. wird aufgerufen...
1.) temp.Swap(*this);   <-- versteh ich nicht, swap tauscht ja, wie verhindert es selbstzuweisung?
2.) Swap(tmp);  <-- unterschied zum obrigen swap?
return *this;

Braunstein

Hallo,

1.) temp.Swap(*this); <-- versteh ich nicht, swap tauscht ja, wie verhindert es selbstzuweisung?

gar nicht. Eine Selbstzuweisung erzeugt hier aber auch keinen Fehler.

2.) Swap(tmp); <-- unterschied zum obrigen swap?

Weniger Schreibarbeit. Eine Dereferenzierung weniger.

Problem bei Selbstzuweisung ist, daß du unter Umständen die Daten löschen würdest, die du gerade kopieren wolltest:

class test
{
  int* val;

  test& operator=(const test& other)
  {
    delete[] val; //Aufräumen
    val=other.val;//hier crasht es bei selbstzuweisung (weil ich gerade other.val gelöscht habe)
    return *this;
  }
}

Mittels swap (es gibt übrigens noch die dritte Variante "swap(*this,other)", die aber idR langsamer ist) wird das Problem umgangen.