Der This-Zeiger

Angenommen du hast eine Klasse "CFoo", dann kann diese Klasse Attribute 
und Methoden besitzen.

Sagen wir, dass die Klasse wie folgt deklariert ist

1

class CFoo

2

{

3

    int m_Val;

4

5

    void SetVal(int Val)

6

    {

7

        m_Val = Val;

8

    }

9

10

    int GetVal()

11

    {

12

        return m_Val;

13

    }

14

};

Nun wird diese Klasse an einer beliebigen Stelle deines Codes beliebig 
oft instanziiert:

1

CFoo Foo1;

2

CFoo Foo2;

Nun rufst du die Methode "SetVal" auf.

1

Foo1.SetVal(666);

Und hier ist die Stelle, wo der this-pointer ins Spiel kommt. Stell dir 
vor, SetVal wäre eine normale C-Funktion. Wäre dem so, so wüsste die 
Funktion nicht, welche Instanz der Klasse CFoo sie ansprechen müsste 
(hier wäre es Foo1). Deshalb wird der Compiler im "Hintergrund" an die 
Funktion "SetVal()" einen Pointer auf die Klasse Foo1 übergeben.
Nun weiß "SetVal()", dass es das Attribut m_Val in der Instanz "Foo1" 
verändern soll.

PS:

Statt

1

    void SetVal(int Val)

2

    {

3

        m_Val = Val;

4

    }

kannst du demnach auch

1

    void SetVal(int Val)

2

    {

3

        this->m_Val = Val;

4

    }

schreiben.

Verstanden? Ansonsten muss Karl Heinz ran ;) ;)

Das hohe C(++) wrote:
> Erst einmal einen riesen Dank für deine ausführliche Antwort.
> Beschäftige mich noch nicht ganz so lange mit der Thematik, daher Gnade,
h> wenn ich mit dem Vokabular nicht ganz richtig umgehe. Verstehe deine
> Ausführungen wie folgt:
> - Wir haben eine Klasse
> - Wir Erstellen die Objekte Foo1 und Foo2

So weit, so gut.

>
> Demanch dürfte doch jetzt im Speicher die beiden Objekte wiedezufinden
> sein mit reserviertem Speicher für die Variablen.

Ist auch richtig.

> Wenn ich jetzt der Variablen m_Val durch Foo1.SetVal(666); einen Wert
> zuweise,
> so ist doch durch Foo1.___(666) eindeutig ein Objekt benannt.

Auch richtig.

> Wozu gebrauch ich dann noch den this-Zeiger?

In dem Fall: gar nicht. Zumindest nicht offensichtlich.
Der Compiler braucht ihn intern um innerhalb der Funktion
auseinanderhalten zu können für welches Objekt denn nun
die Funktion aufgerufen wurde, aber das ist ein Detail,
dass jetzt nicht interessieren muss.


Der this Zeiger ist die C++ Entsprechung für das umgangssprachliche
'Ich' oder 'mein'

this ist die C++ Schreibweise, wie ein Objekt in einer Member-Funktion
von sich selbst sprechen kann.

zb.
2 Klassen: Eine Auto-Klasse und eine Garage. Wenn ein Auto
in die Garage einfährt, muss es sich bei der Garage registrieren.
Umgangssprachlich muss es sagen: Hier bin ich
                                          ***

class Garage
{
  public:
    void Register( Auto* theCar );
};

class Auto
{
  public:
    void ParkIn( Garage* theGarage );
};

void Auto::ParkIn( Garage* theGarage )
{
  // das Auto will in der Garage parken,
  // dazu muss es sich bei der Garage registrieren
  // es 'sagt' zur Garage: Bitte registriere mich
  //                                         ****

  theGarage->Register( this );
}

this ist immer ein Pointer der auf das Objekt zeigt, für
welches eine bestimmte Member Funktion gerade ausgeführt
wird. In vielen Fällen benötigt man den this Pointer nicht,
zb. beim Zugriff auf Member Variablen. Dort ist der this
Pointer implizit

class Auto
{
  public:
    Auto();

  private:
    int AnzahlRaeder;
}

Auto::Auto()
{
  // die Anzahl der Räder für dieses Auto betrage 4
  AnzahlRaeder = 4;

  // hier wurde der this Pointer implizit benutzt
  // man haette genausogut auch schreiben können:
  this->AnzahlRaeder = 4;

  // die Bedeutung wäre identisch
  // Die Anzahl der Räder für das gerade konstruierte
  // Auto Objekt sei 4. Oder aus Sicht dieses Autos:
  // "Ich habe 4 Raeder"
}

aber manchmal, wie zb weiter oben, benötigt man den this
Pointer explizit, damit ein Objekt sich selbst benennen kann.

Ist das jetzt etwas klarer geworden?
this ist einfach nur C++ für 'Ich' oder 'mein' oder 'mich'

Stell dir Objekte wie Personen vor, denen du 'Befehle' geben
kannst. Ein 'Befehl' wird übermittelt, indem man eine Funktion
aufruft. Die Implementierung der Funktion ist dann nichts
anderes als die Ansammlung von Aktionen die dieses Objekt
ausführt, damit es den Befehl befolgen kann. Und zwar
aus Sicht des aktiven Objektes. Zeitweilig muss aber das Objekt
sich selbst ins Spiel bringen, indem es 'ich' oder 'mein' oder
'mich' sagen kann.

Dreh und Angelpunkt der objektorientierten Programmierung ist
die Auffassung, dass Objekte aktive Einheiten sind. In C ist
das noch anders: Da gibt es Strukturen. Diese lungern passiv
im Speicher rum. Weiters gibt es Funktionen, die mit diesen
Strukturen arbeiten. Aber die Strukturen selbst sind einfach
nur passive Daten im Speicher.
Bei der objektorientierten Programmierung bilden Datenstruktur
und Funktionen eine Einheit, eine aktive Einheit, ein Objekt.
Dieses Objekt erledigt eigenständig Befehle, wobei den Befehls-
geber (den Aufrufer einer Funktion) nicht weiter zu interessieren
hat, wie das Objekt einen Befehl ausführt. Aber: Um einen
Befehl auszuführen muss dieses Objekt mit seiner Umwelt (=anderen
Objekten) interagieren. Und genauso wie eine reale Person das
macht, macht das auch ein Objekt: viele Dinge kann es ganz für
sich alleine erledigen. Aber manchmal muss es, genaus wie
auch im richtigen Leben, einen Verweis auf sich selbst bei
anderen Objekten hinterlassen.

Das hohe C(++) wrote:
> Danke an Euch Zwei, die Bedeutung des This-Zeigers ist mir jetzt um
> einiges klarer geworden. Werde es mir zwar noch einmal ganz in Ruhe zu
> Gemüte führen, aber dank Eurer Hilfe ist mir der Sinn schon klar
> geworden. Das Beispiel mit der Garage fand ich sehr verständlich. Es
> können ja zig verschiedenen Autos dort parken wollen. Über den
> This-Zeiger weiß die Garage dann, wer dort wirklich parkt. Stimmt, beim
> Konstruktor muß der zeiger impliziet mitgegeben sein, woher sollte er
> sonst wissen, wem die Daten gehören.
>
> Danke ganz herzlich für Eure Geduld
>
> Andree

Nicht ganz. Ist vielleicht etwas untergegangen in Karl-Heinz Post, aber 
den this pointer solltest du erstmal als etwas "Compiler-internes" 
ansehen. Etwas, was der Compiler benötigt um deinen Code zu kompilieren.

Dieser this-Pointer wird (ohne, dass du es siehst) bei jedem 
Methodenaufruf (außer statische Methoden, aber das ist jetzt erstmal 
wurscht) an die aufgerufene Methode übergeben.

Im Falle von

1

Foo1.SetVal(123);

wird also die "Funktion" SetVal aufgerufen und ihr "im Hintergrund" ein 
Pointer auf Foo1 übergeben. Dieser Pointer wird dann innerhalb der 
Methode "SetVal" zu dem this-Pointer.

Jetzt weiß SetVal() auf welche Instanz der Klasse CFoo er sich beziehen 
muss.

PS: Das ist wieder so ein Thema, dass man relativ schlecht erklären 
kann. (Oder geht es nur mir so ;)). Wenn man sich Gedanken darüber 
macht, wie der Compiler mit Methoden und Attributen umgeht, kommt man 
quasi automatisch auf die Idee des this-Pointers.. Das Problem ist nur, 
sich über den Compiler Gedanken zu machen, setzt wiederum eine gewisse 
Grundkenntnis voraus :-/

14 Jahre alten Thread exhumiert ...
ist das ein neuer Rekord?

merciless