Ver el código de «cpp/language/this»

No tienes permiso para modificar esta página, por el siguiente motivo:
La acción que has solicitado está restringida a los usuarios de uno de estos 2 grupos: Usuarios, Administradores.
Puedes ver y copiar el código fuente de esta página.
{{title|El puntero {{tt|this}}}}
{{cpp/language/classes/navbar}}

===Sintaxis===
{{sdsc begin}}
{{sdsc|{{ttb|this}}}}
{{sdsc end}}

La palabra clave {{tt|this}} es una {{rlp|expressions|expresión}} {{rev inl|until=c++11|{{rlp|value category#rvalue|rvalue}}}}{{rev inl|since=c++11|{{rlp|value category#prvalue|prvalue}}}} cuyo valor es la dirección del {{rlp|overload resolution#Implicit object parameter|parámetro de objeto implícito}} (objeto en el que se llama a la función miembro no estática). Puede aparecer en los siguientes contextos:
@1@ Dentro del cuerpo del cualquier {{rlp|member functions|función miembro}} no estática, incluyendo la {{rlp|initializer list|lista de inicializadores de miembro}}
@2@ dentro de la {{rlp|function|declaración}} de una función miembro no estática en cualquier lugar después de la secuencia de calificación cv (opcional), incluyendo
{{rrev|until=c++17|* {{rlp|except spec|especificación de excepción dinámica}},}}
{{rrev|since=c++11|
* {{rlp|noexcept spec|especificación noexcept}}, y
* el tipo de retorno final
}}

{{rrev|since=c++11|
@3@ dentro del {{rlp|data members#Member initialization|inicializador de miembro por defecto}}
}}

{{tt|this}} solo puede asociarse con la clase más interna donde aparece, incluso si la aparición no es válida en el contexto:
{{source|1=
class Externa
{
    int a[sizeof(*this)];            // error: no dentro de una función miembro
    unsigned int sz = sizeof(*this); // correcto: en un inicializador de miembro por defecto
    void f()
    {
        int b[sizeof(*this)];     // correcto
        struct Interna
        {
            int c[sizeof(*this)]; // error: no dentro de una función miembro de Interna
                                  // 'this' no está asociado a Externa
                                  // incluso si está dentro de una función miembro de Externa
        };
    }
}
}}

El tipo de {{tt|this}} en una función miembro de clase {{tt|X}} es {{tt|X*}} (puntero a X). Si la función miembro está {{rlp|member functions#member functions with cv-qualifiers|declarada con una secuencia de calificadores-cv}} ''cv'', el tipo de {{tt|this}} es {{tt|''cv'' X*}} (puntero a X con idéntica calificación cv). Como los constructores y destructores no se pueden declarar con calificadores cv, el tipo de {{tt|this}} en ellos es siempre {{tt|X*}}, incluso cunado construyen o destruyen un objeto constante.

Cuando se usa un miembro de clase no estático en cualquier contexto donde se permita la palabra clave {{tt|this}} (cuerpos de funciones miembros no estáticas, listas de inicialización de miembro, inicializadores de miembro por defecto), se añade automáticamente un {{ttb|this->}} implícito antes del nombre, resultado una expresión de acceso a miembro (que, si el miembro es una función miembro virtual, resulta es una llamada a función virtual).

En plantillas de clase, {{tt|this}} es una {{rlp|dependent name|expresión dependiente}}, y se puede usar {{tt|this->}} explícito para obligar a otra expresión a volverse dependiente.
{{source|1=
template<typename T>
struct B
{
    int var;
};

template<typename T>
struct D : B<T>
{
    D()
    {
        // var = 1;    // error: 'var' no fue declarado en este ámbito
        this->var = 1; // correcto
    }
};
}}

{{rlp|constructor|Durante la construcción}} de un {{mark unreviewed dr|cwg}}<!-- solo fue constante hasta cwg2271 --> objeto, si se accede al valor del objeto o cualquiera de sus subobjetos a través de un glvalue que no se obtiene, directa o indirectamente, del puntero {{tt|this}} del constructor, el valor del objeto o subobjeto obtenido así no está especificado. Es decir, el puntero this no puede tener un alias en un constructor:
{{source|1=
extern struct D d;
struct D
{
    D(int a) : a(a), b(d.a) {} // b(a) o b(this->a) sería correcto
    int a, b;
};
D d = D(1); // debido a que b(d.a) no se obtuvo mediante this, d.b está sin especificar
}}

Es posible ejecutar {{c|delete this;}}, si el programa puede garantizar que el objeto fue alojado mediante {{c|new}}, sin embargo, esto hace que todos los punteros al objeto desasignado no sean válidos, incluido el puntero {{tt|this}} en sí mismo: después de {{c|delete this;}}, dicha función miembro no puede hacer referencia a un miembro de una clase (ya que esto implica una desreferencia implícita de {{tt|this}}) y no se puede llamar a ninguna otra función miembro.
{{rrev|since=c++11|
Esto se usa, por ejemplo, en la función miembro del bloque de control de {{lc|std::shared_ptr}} responsable de disminuir el contador de referencias, cuando la última referencia al objeto administrado queda fuera del ámbito.
}}
{{source|1=
class ref
{
    // ...
    void incRef() { ++mnRef; }
    void decRef() { if (--mnRef == 0) delete this; }
};
}}

===Ejemplo===
{{source
|
|code=
class T
{
    int x;

    void foo()
    {
        x = 6;       // igual a this->x = 6;
        this->x = 5; // uso explícito de this->
    }

    void foo() const
    {
//      x = 7; // Error: *this es constante
    }

    void foo(int x) // el parámetro x oculta al miembro con el mismo nombre
    {
        this->x = x; // x sin calificar se refiere al parámetro
                     // se requiere 'this->' para desambiguación
    }

    int y;
    T(int x) : x(x),      // usa el parámetro x para iniciar el miembro x
               y(this->x) // usa el miembro x para iniciar el miembro y
    {}

    T& operator=(const T& b)
    {
        x = b.x;
        return *this; // muchos operadores sobrecargados devuelven *this
    }
};
}}

===Informe de defectos===
{{dr list begin}}
{{dr list item|wg=cwg|dr=760|std=C++98|before=cuando {{tt|this}} se usa en una clase anidada,<br> no estaba especificado si está asociado con la<br> clase anidada o con la que la envuelve|after={{tt|this}} siempre se asocia con la clase anidada más<br> interna, independientemente de si está en<br>una función miembro no estática}}
{{dr list end}}

{{langlinks|de|en|fr|it|ja|pt|ru|zh}}
Plantillas usadas en esta página:
Volver a cpp/language/this.
cppreference.com

Buscar

Espacios de nombres

Variantes

Vistas

Acciones

Ver el código de «cpp/language/this»

Navegación

Herramientas
