The this pointer

Syntax

Der Ausdruck this ist ein prvalue Ausdruck , dessen Wert die Adresse des impliziten Objektparameters (Objekt, auf dem die implizite Objekt-Memberfunktion aufgerufen wird) ist. Er kann in den folgenden Kontexten auftreten:

Erklärung

this kann sich nur mit der innersten umschließenden Klasse seines Auftretens assoziieren, selbst wenn das Auftreten im Kontext ungültig ist:

class Outer
{
    int a[sizeof(*this)];            // Fehler: nicht innerhalb einer Memberfunktion
    unsigned int sz = sizeof(*this); // OK: in Default-Member-Initializer
    void f()
    {
        int b[sizeof(*this)];     // OK
        struct Inner
        {
            int c[sizeof(*this)]; // Fehler: nicht innerhalb einer Memberfunktion von Inner
                                  // „this“ ist nicht mit Outer assoziiert
                                  // selbst wenn es sich in einer Memberfunktion von Outer befindet
        };
    }
};

Der Typ von this in einer Memberfunktion der Klasse X ist X* (Zeiger auf X). Wenn die Memberfunktion mit einer CV-Qualifizierer-Sequenz deklariert ist cv , ist der Typ von this cv X* (Zeiger auf identisch CV-qualifiziertes X). Da Konstruktoren und Destruktoren nicht mit CV-Qualifizierern deklariert werden können, ist der Typ von this in ihnen stets X* , selbst wenn ein konstantes Objekt konstruiert oder zerstört wird.

In Klassentemplates ist this ein abhängiger Ausdruck , und explizites this - > kann verwendet werden, um einen anderen Ausdruck zu einem abhängigen Ausdruck zu machen.

template<typename T>
struct B
{
    int var;
};
template<typename T>
struct D : B<T>
{
    D()
    {
        // var = 1;    // Fehler: "var" wurde in diesem Gültigkeitsbereich nicht deklariert
        this->var = 1; // OK
    }
};

Während der Konstruktion eines Objekts, wenn auf den Wert des Objekts oder eines seiner Teilobjekte über einen Glvalue zugegriffen wird, der nicht direkt oder indirekt vom this -Zeiger des Konstruktors erhalten wurde, ist der so erhaltene Wert des Objekts oder Teilobjekts unspezifiziert. Mit anderen Worten: Der this-Zeiger kann in einem Konstruktor nicht gealiast werden:

extern struct D d;
struct D
{
    D(int a) : a(a), b(d.a) {} // b(a) oder b(this->a) wäre korrekt
    int a, b;
};
D d = D(1); // da b(d.a) nicht a durch this bezogen hat, ist d.b jetzt nicht spezifiziert

Es ist möglich, delete this ; auszuführen, wenn das Programm garantieren kann, dass das Objekt durch new alloziert wurde. Allerdings macht dies jeden Zeiger auf das freigegebene Objekt ungültig, einschließlich des this -Zeigers selbst: Nachdem delete this ; zurückgekehrt ist, kann eine solche Memberfunktion nicht auf ein Klassenmitglied verweisen (da dies eine implizite Dereferenzierung von this beinhaltet) und keine andere Memberfunktion darf aufgerufen werden.

Dies kann in der Memberfunktion des referenzzählenden Zeigers (zum Beispiel, std::shared_ptr ) (since C++11) verwendet werden, die für das Dekrementieren des Referenzzählers verantwortlich ist, wenn die letzte Referenz auf das verwaltete Objekt den Gültigkeitsbereich verlässt.

class ref
{
    // ...
    void incRef() { ++mnRef; }
    void decRef() { if (--mnRef == 0) delete this; }
};

`-Tags befindet und C++-spezifische Begriffe enthält. Der umgebende HTML-Code wurde ebenfalls unverändert beibehalten.

Schlüsselwörter

this

Beispiel

class T
{
    int x;
    void foo()
    {
        x = 6;       // dasselbe wie this->x = 6;
        this->x = 5; // explizite Verwendung von this->
    }
    void foo() const
    {
    //  x = 7; // Fehler: *this ist konstant
    }
    void foo(int x) // Parameter x verdeckt das Mitglied mit demselben Namen
    {
        this->x = x; // nicht qualifiziertes x bezieht sich auf den Parameter
                     // "this->" wird zur Unterscheidung benötigt
    }
    int y;
    T(int x) : x(x),      // verwendet Parameter x zur Initialisierung des Mitglieds x
               y(this->x) // verwendet Mitglied x zur Initialisierung des Mitglieds y
    {}
    T& operator=(const T& b)
    {
        x = b.x;
        return *this; // viele überladene Operatoren geben *this zurück
    }
};

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.