Was ist der "dieser" Zeiger?

Question

Ich bin ziemlich neu in C++, und ich verstehe nicht, was die this Zeiger tun im folgende Szenario:

void do_something_to_a_foo(Foo *foo_instance); 


void Foo::DoSomething() 
{ 
    do_something_to_a_foo(this); 
} 

Ich packte das von jemandem anderer Post hier.

Was bedeutet this zeigen? Ich bin verwirrt. Die Funktion hat keine Eingabe, also was macht this?

Answer 1

this bezieht sich auf das aktuelle Objekt.

Das Schlüsselwort this identifiziert einen speziellen Typ von Zeiger. Angenommen, Sie erstellen ein Objekt mit dem Namen x von class A, und class A hat eine nicht statische Elementfunktion f(). Wenn Sie die Funktion x.f() aufrufen, speichert das Schlüsselwort this im Rumpf von f() die Adresse x.

Answer 2

Dieser ist ein Zeiger auf self (das Objekt, das dieses aufgerufen hat).

Angenommen, Sie haben ein Objekt der Klasse Auto namens car, die eine nicht statische Methode getColor() haben, der Aufruf dieser innerhalb getColor() gibt die Adresse von Auto (die Instanz der Klasse) zurück.

Statische Elementfunktionen haben keinen Zeiger (da sie nicht auf eine Instanz bezogen sind).

Answer 3

Die kurze Antwort ist, dass this ist ein spezielles Schlüsselwort, das "dieses" Objekt identifiziert - das, auf dem Sie gerade arbeiten. Die etwas längere, komplexere Antwort lautet wie folgt:

Wenn Sie eine class haben, kann es Elementfunktionen von zwei Typen haben: static und nicht static. Die Nichtmitgliedsfunktionen von static müssen auf einer bestimmten Instanz der Klasse arbeiten, und sie müssen wissen, wo sich diese Instanz befindet. Um ihnen zu helfen, definiert die Sprache eine implizite Variable (dh eine, die automatisch für Sie deklariert wird, wenn sie benötigt wird, ohne dass Sie etwas tun müssen), die this heißt und die automatisch so ausgeführt wird, dass sie auf die bestimmte Instanz der Klasse verweist welche die Mitgliedsfunktion betreibt.

Betrachten Sie dieses einfache Beispiel:

#include <iostream> 

class A 
{ 
public: 
    A() 
    { 
     std::cout << "A::A: constructed at " << this << std::endl; 
    } 

    void SayHello() 
    { 
     std::cout << "Hi! I am the instance of A at " << this << std::endl; 
    } 
}; 

int main(int, char **) 
{ 
    A a1; 
    A a2; 

    a1.SayHello();   
    a2.SayHello(); 

    return 0; 
} 

Wenn Sie diese kompilieren und ausführen, beachten Sie, dass der Wert von this zwischen a1 und a2 unterscheidet.

Answer 4

Dies bedeutet das Objekt von Foo, auf dem DoSomething() aufgerufen wird.Ich erkläre es mit Beispiel

void do_something_to_a_foo(Foo *foo_instance){ 
    foo_instance->printFoo(); 
} 

und unsere Klasse

class Foo{ 
    string fooName; 
    public: 
     Foo(string fName); 
     void printFoo(); 
     void DoSomething(); 
}; 

Foo::Foo(string fName){ 
    fooName = fName; 
} 
void Foo::printFoo(){ 
     cout<<"the fooName is: "<<fooName<<endl; 
} 
void Foo::DoSomething(){ 
    do_something_to_a_foo(this); 
} 

jetzt wir Objekte wie

Foo fooObject("first); 
f.DoSomething();//it will prints out first 

ähnlich instanziiert, was auch immer der String an Foo-Konstruktor übergeben werden, wird beim Aufruf DoSomething gedruckt werden().
Weil zum Beispiel in DoSomething() des obigen Beispiels "this" fooObject bedeutet und in do_something_to_a_foo() fooObject als Referenz übergeben wird.

Answer 5

Nichtstatische Elementfunktionen wie Foo::DoSomething haben einen impliziten Parameter, dessen Wert für this verwendet wird. Die Norm gibt dies in C++ an. 11 §5.2.2/4:

Beim Aufruf einer Funktion wird jeder Parameter (8.3.5) mit seinem entsprechenden Argument initialisiert (8.5, 12.8, 12.1). [Hinweis: Solche Initialisierungen sind unbestimmt hintereinander angeordnet (1.9) - Endnote] Wenn die Funktion eine nicht statische Elementfunktion ist, wird der Parameter this der Funktion (9.3.2) mit einem Zeiger auf den Wert initialisiert Objekt des Aufrufs, konvertiert wie durch eine explizite Typumwandlung (5.4).

Als Ergebnis benötigen Sie ein Objekt Foo, um DoSomething aufzurufen. Dieses Objekt wird einfach this.

Der einzige Unterschied (und es ist trivial) zwischen dem this Schlüsselwort und einem normalen, explizit erklärt const Zeigerparameter ist, dass Sie nicht die Adresse des this nehmen.

Answer 6

Nur einige zufällige Fakten über this die anderen Antworten ergänzen:

class Foo { 
public: 
    Foo * foo() { return this; } 
    const Foo * cfoo() const { return this; /* return foo(); is an error */ } 
}; 

Foo x;  // can call either x.foo() or x.cfoo() 
const Foo y; // can only call x.cfoo() 

Wenn das Objekt const ist, wird die Art der this ein Zeiger auf const.

---

class Bar { 
    int x; 
    int y; 
public: 
    Bar() : x(1), y(2) {} 
    void bar (int x = 3) { 
     int y = 4; 
     std::cout << "x: " << x << std::endl; 
     std::cout << "this->x: " << this->x << std::endl; 
     std::cout << "y: " << y << std::endl; 
     std::cout << "this->y: " << this->y << std::endl; 
    } 
}; 

this Der Zeiger kann ein Element zuzugreifen, verwendet werden, die von einem Funktionsparameter oder einer lokalen Variablen überschattet.

---

template <unsigned V> 
class Foo { 
    unsigned v; 
public: 
    Foo() : v(V) { std::cout << "<" << v << ">" << " this: " << this << std::endl; } 
}; 

class Bar : public Foo<1>, public Foo<2>, public Foo<3> { 
public: 
    Bar() { std::cout << "Bar this: " << this << std::endl; } 
}; 

Mehrfachvererbung wird die verschieden Eltern führen zu unterschiedlichen this Werte haben. Nur das erste geerbte Elternelement hat denselben Wert this wie das abgeleitete Objekt.

Answer 7

Es ist ein lokaler pointer.It bezieht sich auf das aktuelle Objekt als lokales Objekt

Answer 8

Acc. Orientiertes Programmieren mit C++ durch Balaguruswamy

this zu-Objekt ist ein Zeiger, der auf den Objektpunkten, für die this Funktion aufgerufen wurde.Zum Beispiel wird der Funktionsaufruf A.max() den Zeiger this auf die Adresse des Objekts setzen. Der Zeiger this fungiert als implizites Argument für alle Elementfunktionen.

Hier finden Sie ein großartiges Beispiel für this Zeiger. Es hat mir auch geholfen, das Konzept zu verstehen.

Answer 9

Ein Zeiger ist ein Programmiersprachenobjekt, dessen Wert sich auf einen anderen Wert bezieht, der an anderer Stelle im Computerspeicher unter Verwendung seiner Speicheradresse gespeichert ist.

Es kann auch gesagt werden, dass ein Zeiger eine Variable ist, die eine Speicheradresse als Wert enthält.