DANKE!!

Hier ist es imho relativ einfach beschrieben, wozu der this-Zeiger da ist.

Gruß Caipi

ich weiß jetzt, dass wo zwei zeiger irgendwo hinzeigen, dass sie auf dasselbe objekt zeigen...

aber schlauer bin ich noch nicht...

deswegen HELP!!!

const testklasse& testklasse::operator=(const testklasse& rechts){
   //...
   return *this;
}

danke für eure hilfe, so richtig sagt mir das alles immernoch nichts, aber liegt wahrscheinlich daran, dass ich erst grad mit oop angefabgen hab...

Also: Der this-Zeiger ist ein ganz normaler Zeiger, den du innerhalb von Element-Funktionen benutzen kannst und der auf das Objekt zeigt, dessen Elementfunktion du aufrufst.

Beispiel:
Du hast ein Objekt obj der Klasse Foo:

class Foo
{
   ...
};

// ...
int main()
{
    Foo obj;
   // ...
}

Wie jedes andere Objekt auch, besitzt obj eine Adresse. Diese kannst du leicht herausfinden in dem du schreibst:

std::cout << " address of obj: " << &obj << std::endl;

Wie aber kannst du die Adresse von obj innerhalb einer Elementfunktion von Foo herausfinden? Um dies ebenfalls tun zu können gibt es den Zeiger this. Innerhalb einer Elementfunktion schreibst du

std::cout << "address of obj: " << this << std::endl;

Woher aber weiß die Elementfunktion die Adresse von dem Objekt, das sie aufgerufen hat? Das weiß sie, da bei jedem Memberfunktionsaufruf implizit der this-Zeiger mit der Adresse des aufzurufenden Objekts initialisiert wird.
Dank dieser Übergabe weiß die Elementfunktion auch, von welchem Objekt sie die Daten bearbeiten/ausgeben/etc. soll.

Beispiel:
Du hast wieder die Klasse Foo. Zusätzlich aber Zwei Instanzen dieser Klasse obj1 und obj2.

class Foo
{
    size_t x, y;

    public:
      Foo(size_t x_, size_t y_) x(x_), y(y_) {}
      void do_something()
      {
          std::cout << "x = " << x << "; y = " << y << std::endl;
      }
};

int main()
{
    Foo obj1(9, 99), obj2(18, 180);

    obj1.do_something();
    obj2.do_something();

    return 0;
}

Woher weiß hier die Element-Funktion do_something(), die für obj1 aufgerufen wird, dass sie die Variablen von obj1 ausgeben soll und nicht die von obj2? (Umgekehrtes gilt für do_something() im Zusammenhang mit dem Objekt obj2).
Dank dem this-Zeiger!
Dieser Zeiger, der - wie bereits erwähnt - implizit der Element-Funktion übergeben wird, wird dereferenziert und die Variablen x und/oder y, die sich an dieser Adresse befinden werden angezeigt. => Da innerhalb einer Element-Funktion, die obj1 aufgerufen hat, der this-Zeiger die Adresse von obj1 beinhaltet, werden x und y von Obj1 angezeigt. (Umgekehrtes gilt hier wiederrum für den zweiten Aufruf von do_something im Zusammenhang mit obj2).

/edit: die Zeile

std::cout << "x = " << x << "; y = " << y << std::endl;

innerhalb der Memberfunktion do_something() kannst du (eventuell zum besseren Verständnis) auch durch die folgende ersetzen:

std::cout << "x = " << this->x << "; y = " << this->y << std::endl; // bewirkt das gleiche

Jetzt wird es denke ich (noch) klarer: Es werden die Daten des Objekts, auf das this zeigt, ausgegeben.

Hier vielleicht noch was dazu: http://www.c-plusplus.net/forum/viewtopic-var-t-is-39465.html.

Gruß Caipi