El puntero this.

El puntero this es un puntero accesible solo dentro de las funciones miembro no estáticas de un tipo class, struct o union. Señala al objeto para el que se llama a la función miembro. Las funciones miembro estáticas no tienen un puntero this.

Sintaxis

this
this->member-identifier

Comentarios

El puntero this de un objeto no forma parte del objeto en sí. No forma parte del resultado de una instrucción sizeof en el objeto. Cuando se llama a una función miembro no estática para un objeto, el compilador pasa la dirección del objeto a la función como un argumento oculto. Por ejemplo, la siguiente llamada de función:

myDate.setMonth( 3 );

se puede interpretar de esta manera:

setMonth( &myDate, 3 );

La dirección del objeto está disponible desde la función miembro como puntero this. La mayoría de los usos del puntero this son implícitos. Es válido, aunque innecesario, usar explícitamente this cuando se hace referencia a los miembros de class. Por ejemplo:

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

La expresión *this suele utilizarse para devolver el objeto actual desde una función miembro:

return *this;

El puntero this también se usa para protegerse de la referencia automática:

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

Nota:

Dado que el puntero this no es modificable, no se permiten asignaciones al puntero this. Las implementaciones anteriores de C++ permitían asignaciones a this.

En ocasiones, el puntero this se usa directamente; por ejemplo, para manipular estructuras de datos a los que se hace referencia automáticamente, donde se requiere la dirección del objeto actual.

Ejemplo

// 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

Tipo del puntero this

El tipo del puntero this cambia en función de si la declaración de función incluye las palabras clave const o volatile. La siguiente sintaxis describe el tipo de this en una función miembro:

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

El declarador de la función miembro determina cv-qualifier-list. Puede ser const o volatile (o ambos). class-type es el nombre del class.

No se puede reasignar el puntero this. Los calificadores const o volatile que se usan en la declaración de funciones miembro se aplican a la instancia class a la que apunta el puntero this en el ámbito de dicha función, como se muestra en la siguiente tabla:

Declaración de función miembro	tipo de puntero de this para un class denominado myClass
void Func()	myClass *
void Func() const	const myClass *
void Func() volatile	volatile myClass *
void Func() const volatile	const volatile myClass *

En la siguiente tabla se explica más sobre const y volatile.

Semántica de modificadores this

Modificador	Significado
const	No se pueden cambiar los datos de los miembros; no se pueden invocar funciones miembro que no sean const.
volatile	Los datos de miembros se cargan desde la memoria cada vez que se obtiene acceso; deshabilita ciertas optimizaciones.

Es un error pasar un objeto const a una función miembro que no sea const.

De igual forma, es un error pasar un objeto volatile a una función miembro que no sea volatile.

Las funciones miembro declaradas como const no pueden cambiar los datos de los miembros. En funciones const, el puntero this es un puntero a un objeto const.

Nota:

Los constructores y destructores no se pueden declarar como const o volatile. Pueden, sin embargo, invocarse en objetos const o volatile.

Consulte también

Palabras clave