Der this-Zeiger

Der this-Zeiger ist ein Zeiger, auf den nur in nicht statischen Memberfunktionen des Typs class, struct oder union zugegriffen werden kann. Er zeigt auf das Objekt, für das die Memberfunktion aufgerufen wird. Statische Memberfunktionen haben keinen this-Zeiger.

Syntax

this
this->member-identifier

Hinweise

Der this-Zeiger eines Objekts ist nicht Teil des Objekts selbst. Er ist nicht Teil des Ergebnisses einer sizeof-Anweisung für das Objekt. Wenn eine nicht statische Memberfunktion für ein Objekt aufgerufen wird, übergibt der Compiler die Adresse des Objekts als ausgeblendetes Argument an die Funktion. Folgender Funktionsaufruf kann beispielsweise:

myDate.setMonth( 3 );

kann interpretiert werden als:

setMonth( &myDate, 3 );

Die Adresse des Objekts ist innerhalb der Memberfunktion als this-Zeiger verfügbar. this-Zeiger werden meistens implizit verwendet. Es ist zulässig, wenn auch unnötig, this explizit für den Verweis auf Member von class zu verwenden. Zum Beispiel:

void Date::setMonth( int mn )
{
   month = mn;            // These three statements
   this->month = mn;      // are equivalent
   (*this).month = mn;
}

Der Ausdruck *this wird häufig verwendet, um das aktuelle Objekt aus einer Memberfunktion zurückzugeben:

return *this;

Der this-Zeiger wird auch verwendet, um vor Selbstverweisen zu schützen:

if (&Object != this) {
// do not execute in cases of self-reference

Hinweis

Da der this-Zeiger unveränderlich ist, sind Zuweisungen zum this-Zeiger nicht zulässig. Frühere Implementierungen von C++ ließen Zuweisungen zu this zu.

Gelegentlich wird der this-Zeiger direkt verwendet, beispielsweise um auf sich selbst verweisende Datenstrukturen zu bearbeiten, für die die Adresse des aktuellen Objekts erforderlich ist.

Beispiel

// this_pointer.cpp
// compile with: /EHsc

#include <iostream>
#include <string.h>

using namespace std;

class Buf
{
public:
    Buf( char* szBuffer, size_t sizeOfBuffer );
    Buf& operator=( const Buf & );
    void Display() { cout << buffer << endl; }

private:
    char*   buffer;
    size_t  sizeOfBuffer;
};

Buf::Buf( char* szBuffer, size_t sizeOfBuffer )
{
    sizeOfBuffer++; // account for a NULL terminator

    buffer = new char[ sizeOfBuffer ];
    if (buffer)
    {
        strcpy_s( buffer, sizeOfBuffer, szBuffer );
        sizeOfBuffer = sizeOfBuffer;
    }
}

Buf& Buf::operator=( const Buf &otherbuf )
{
    if( &otherbuf != this )
    {
        if (buffer)
            delete [] buffer;

        sizeOfBuffer =  strlen( otherbuf.buffer ) + 1;
        buffer = new char[sizeOfBuffer];
        strcpy_s( buffer, sizeOfBuffer, otherbuf.buffer );
    }
    return *this;
}

int main()
{
    Buf myBuf( "my buffer", 10 );
    Buf yourBuf( "your buffer", 12 );

    // Display 'my buffer'
    myBuf.Display();

    // assignment operator
    myBuf = yourBuf;

    // Display 'your buffer'
    myBuf.Display();
}

my buffer
your buffer

Typ des this-Zeigers

Der Typ des this-Zeigers ändert sich, je nachdem, ob in der Funktionsdeklaration die Schlüsselwörter const und/oder volatile angegeben werden. Die folgende Syntax beschreibt den Typ von this in einer Memberfunktion:

[cv-qualifier-list] class-type * const this

Der Deklarator der Memberfunktion bestimmt cv-qualifier-list. Er kann const sein oder volatile (oder beides). class-type ist der Name der class.

Der this-Zeiger kann nicht neu zugewiesen werden. Die Qualifizierer const und volatile, die in der Memberfunktionsdeklaration verwendet werden, gelten für die class-Instanz, auf die vom this-Zeiger im Bereich dieser Funktion verwiesen wird, wie in der folgenden Tabelle dargestellt:

Memberfunktionsdeklaration	Typ des this-Zeigers für eine class namens myClass
void Func()	myClass *
void Func() const	const myClass *
void Func() volatile	volatile myClass *
void Func() const volatile	const volatile myClass *

In der folgenden Tabelle erfahren Sie mehr über const und volatile.

Semantik von this-Modifizierern

Modifizierer	Bedeutung
const	Memberdaten können nicht geändert werden. Memberfunktionen, die nicht const sind, können nicht aufgerufen werden.
volatile	Memberdaten werden aus dem Arbeitsspeicher geladen, wenn darauf zugegriffen wird. Bestimmte Optimierungen werden deaktiviert.

Es nicht zulässig, ein const-Objekt an eine Memberfunktion zu übergeben, die nicht const ist.

Außerdem ist es nicht zulässig, ein volatile-Objekt an eine Memberfunktion zu übergeben, die nicht volatile ist.

Memberfunktionen, die als const deklariert wurden, können Memberdaten nicht ändern. In const-Funktionen ist der this-Zeiger ein Zeiger auf ein const-Objekt.

Hinweis

Konstruktoren und Destruktoren können nicht als const oder volatile deklariert werden. Sie können jedoch für const- oder volatile-Objekte aufgerufen werden.

Weitere Informationen

Schlüsselwörter