¿Cuál es el puntero ‘este’?

Soy bastante nuevo en C ++, y no entiendo qué hace this puntero en el siguiente escenario:

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

Agarré eso de la publicación de otra persona aquí.

¿A qué apunta this ? Estoy confundido. La función no tiene entrada, entonces, ¿qué está haciendo this ?

this refiere al objeto actual.

La palabra clave this identifica un tipo especial de puntero. Supongamos que crea un objeto llamado x de la class A , y la class A tiene una función miembro no estática f() . Si llama a la función xf() , la palabra clave this en el cuerpo de f() almacena la dirección de x .

La respuesta corta es que this es una palabra clave especial que identifica “este” objeto, en el que usted está operando actualmente. La respuesta un poco más larga y compleja es la siguiente:

Cuando tiene una class , puede tener funciones miembro de dos tipos: static y no static . Las funciones miembro no static deben operar en una instancia particular de la clase, y necesitan saber dónde está esa instancia. Para ayudarlos, el lenguaje define una variable implícita (es decir, una que se declara automáticamente cuando se necesita sin tener que hacer nada) que se llama this y que se creará automáticamente para apuntar a la instancia particular de la clase en que la función miembro está funcionando.

Considera este simple ejemplo:

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

Cuando comstack y ejecuta esto, observe que el valor de this es diferente entre a1 y a2 .

Solo algunos hechos al azar sobre this para complementar las otras respuestas:

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

Cuando el objeto es const , el tipo de this convierte en un puntero 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 puntero se puede usar para acceder a un miembro que fue eclipsado por un parámetro de función o una variable local.


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

La herencia múltiple hará que los diferentes padres tengan valores diferentes. Solo el primer padre heredado tendrá el mismo valor que el objeto derivado.

este es un puntero al yo (el objeto que invocó esto ).

Supongamos que tiene un objeto de clase Coche llamado automóvil que tiene un método no estático getColor (), la llamada a esto dentro getColor () devuelve la dirección del automóvil (la instancia de la clase).

Las funciones de miembro estático no tienen este puntero (ya que no están relacionadas con una instancia).

esto significa el objeto de Foo en el que se invoca DoSomething (). Lo explico con un ejemplo

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

y nuestra clase

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

ahora instanciamos objetos como

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

de forma similar, cualquiera que sea la cadena que se pasará al constructor de Foo se imprimirá al llamar a DoSomething ().
Porque, por ejemplo, en DoSomething () del ejemplo anterior, "this" significa fooObject y en do_something_to_a_foo () fooObject se pasa por referencia.

Las funciones de miembro no estático como Foo::DoSomething tienen un parámetro implícito cuyo valor se usa para this . El estándar especifica esto en C ++ 11 §5.2.2 / 4:

Cuando se llama a una función, cada parámetro (8.3.5) debe inicializarse (8.5, 12.8, 12.1) con su argumento correspondiente. [Nota: Dichas inicializaciones están secuenciadas indeterminadamente una respecto de la otra (1.9) – nota final] Si la función es una función miembro no estática, this parámetro de la función (9.3.2) se inicializará con un puntero al objeto de la llamada, convertido como por una conversión de tipo explícita (5.4).

Como resultado, necesita un objeto Foo para llamar a DoSomething . Ese objeto simplemente se convierte en this .

La única diferencia (y es trivial) entre la palabra clave this y un parámetro const puntero normal declarado explícitamente es que no puede tomar la dirección de this .

Acc. Progtwigción Orientada a Objetos con c ++ por Balaguruswamy

this es un puntero que apunta al objeto para el que se llamó this función. Por ejemplo, la llamada de función A.max() establecerá el puntero a la dirección del objeto. El puntero this es actúa como un argumento implícito para todas las funciones miembro.

Encontrará un gran ejemplo de this puntero aquí. También me ayudó a entender el concepto. http://www.learncpp.com/cpp-tutorial/8-8-the-hidden-this-pointer/

Es un puntero local. Se refiere al objeto actual como un objeto local

Un puntero es un objeto de lenguaje de progtwigción, cuyo valor se refiere a los puntos a otro valor almacenado en otro lugar en la memoria de la computadora utilizando su dirección de memoria.

También se puede decir que un puntero es una variable que contiene una dirección de memoria como su valor.