Qual è il puntatore “questo”?

Sono abbastanza nuovo per C ++ e non capisco cosa fa this puntatore nel seguente scenario:

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

L’ho preso dal post di qualcun altro qui.

Cosa indica this ? Non ho capito bene. La funzione non ha input, quindi cosa sta facendo?

this riferisce all’attuale object.

La parola chiave identifica un tipo speciale di puntatore. Supponiamo che tu crei un object chiamato x di class A e che la class A abbia una funzione membro non statica f() . Se chiami la funzione xf() , la parola chiave this nel corpo di f() memorizza l’indirizzo di x .

La risposta breve è che this è una parola chiave speciale che identifica “questo” object – quello su cui si sta attualmente operando. La risposta leggermente più lunga e più complessa è questa:

Quando hai una class , può avere funzioni membro di due tipi: static e non static . Le funzioni membro non static devono operare su una particolare istanza della class e devono sapere dove si trova l’istanza. Per aiutarli, la lingua definisce una variabile implicita (cioè una che viene dichiarata automaticamente per te quando è necessaria senza che tu debba fare nulla) che viene chiamata this e che verrà automaticamente fatta puntare alla particolare istanza della class su che la funzione membro sta funzionando.

Considera questo semplice esempio:

 #include  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; } 

Quando lo compili e lo esegui, osserva che il valore di this è diverso tra a1 e a2 .

Solo alcuni fatti casuali su this per integrare le altre risposte:

 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() 

Quando l’object è const , il tipo di this diventa un puntatore a 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 puntatore può essere utilizzato per accedere a un membro che è stato oscurato da un parametro di funzione o una variabile locale.


 template  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; } }; 

L'ereditarietà multipla farà sì che i diversi genitori abbiano valori diversi. Solo il primo genitore ereditato avrà lo stesso valore dell'object derivato.

questo è un puntatore a sé (l’object che ha invocato questo ).

Supponiamo di avere un object di class Car chiamato auto che ha un metodo non statico getColor (), la chiamata a questo all’interno di getColor () restituisce l’indirizzo di auto (l’istanza della class).

Le funzioni membro statiche non hanno questo puntatore (poiché non sono correlate a un’istanza).

questo significa l’object di Foo su cui viene richiamato DoSomething (). Lo spiego con l’esempio

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

e la nostra class

 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: "< 

ora istanziamo oggetti come

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

allo stesso modo, qualunque sia la stringa passata a Foo, il costruttore verrà stampato quando chiama DoSomething ().
Perché per esempio in DoSomething () dell'esempio precedente "questo" significa fooObject e in do_something_to_a_foo () fooObject viene passato per riferimento.

Le funzioni membro non statiche come Foo::DoSomething hanno un parametro implicito il cui valore viene utilizzato per this . Lo standard lo specifica in C ++ 11 §5.2.2 / 4:

Quando viene chiamata una funzione, ciascun parametro (8.3.5) deve essere inizializzato (8.5, 12.8, 12.1) con l’argomento corrispondente. [Nota: Tali inizializzazioni sono sequenzialmente indeterminate l’una rispetto all’altra (1.9) – nota finale] Se la funzione è una funzione membro non statico, this parametro della funzione (9.3.2) deve essere inizializzato con un puntatore al object della chiamata, convertito come da una conversione di tipo esplicito (5.4).

Di conseguenza, è necessario un object Foo per chiamare DoSomething . Quell’object diventa semplicemente this .

L’unica differenza (ed è banale) tra this parola chiave e un normale parametro puntatore const dichiarato esplicitamente è che non puoi prendere l’indirizzo di this .

Acc. alla programmazione orientata agli oggetti con c ++ di Balaguruswamy

this è un puntatore che punta all’object per cui è stata chiamata this funzione. Ad esempio, la funzione chiamata A.max() imposterà il puntatore sull’indirizzo dell’object. Il puntatore si comporta come un argomento implicito per tutte le funzioni membro.

Qui troverai un ottimo esempio di this puntatore. Mi ha anche aiutato a capire il concetto. http://www.learncpp.com/cpp-tutorial/8-8-the-hidden-this-pointer/

È un puntatore locale. Si riferisce all’object corrente come object locale

Un puntatore è un object del linguaggio di programmazione, il cui valore si riferisce ai punti di un altro valore memorizzato altrove nella memoria del computer utilizzando il suo indirizzo di memoria.

Si può anche dire che un puntatore è una variabile che contiene un indirizzo di memoria come valore.