¿Hay alguna razón para usar esto->

Question

He programado en C++ durante muchos años y todavía tengo dudas sobre una cosa. En muchos lugares de otro código de la gente que veo algo así como:

void Classx::memberfunction() 
{ 
    this->doSomething(); 
} 

Si necesito para importar/usar ese código, basta con quitar la parte this->, y nunca he visto nada roto o tener algún efectos secundarios.

void Classx::memberfunction() 
{ 
    doSomething(); 
} 

Entonces, ¿conoce alguna razón para usar tal construcción?

EDITAR: Tenga en cuenta que estoy hablando de funciones de miembros aquí, no de variables. Entiendo que se puede usar cuando quiera hacer una distinción entre una variable miembro y un parámetro de función.

EDIT: aparente duplicado: Are there any reasons not to use "this" ("Self", "Me", ...)?

Answer 1

Para garantizar que se activa errores de compilación si hay una macro que podría definirse con el mismo nombre que su función de miembro y no está seguro de si ha sido fiable indefinido.

No es broma, estoy bastante seguro de que he tenido que hacer exactamente esto por eso!

Answer 2

se me ocurre la legibilidad como cuando se utiliza el paréntesis adicional para dejar las cosas claras.

Answer 3

No creo que haga una diferencia en el compilador, pero siempre escribo esto-> porque creo que hace que el código se auto-documente.

Answer 4

Creo que es principalmente como una ayuda para el lector. Hace explícito que lo que se llama es un método en el objeto, y no una función ordinaria. Al leer el código, puede ser útil saber que la función llamada puede cambiar campos en el objeto actual, por ejemplo.

Answer 5

Si hay otra variable en el mismo ámbito con el mismo nombre, this-> eliminará la ambigüedad.

void Bar::setFoo(int foo) 
{ 
    this->foo = foo; 
} 

También deja en claro que se está refiriendo a una variable/función miembro.

Answer 6

Desambiguación: en caso de que tenga otra función/variable de denominación similar en el mismo espacio de nombres? Nunca he visto el uso por ninguna otra razón.

Answer 7

Es su propia elección. Lo encuentro más claro cuando usas esto. Pero si no te gusta, puedes omitirlo.

Answer 8

Como "código de razón", para distinguir un parámetro o valor local (que tiene prioridad) de un miembro de:

class Foo 
{ 
    int member; 
    void SetMember(int member) 
    { 
     this->member = member; 
    } 
} 

Sin embargo, eso es malo practive para empezar, y por lo general pueden ser resueltos a nivel local.

La segunda razón es más "entorno": a veces ayuda a Intellisense a filtrar lo que realmente estoy buscando. Sin embargo, también creo que cuando use esto para encontrar el miembro que estoy buscando también debería eliminarlo.

Así que sí, hay buenas razones, pero todas son temporales (y malas en el largo plazo).

Answer 9

Esto es realmente una cuestión de estilo y se aplica a muchos otros lenguajes como Java y C#. Algunas personas prefieren ver el this explícito (o self, o Me, o lo que sea) y otros no. Simplemente haga lo que esté en sus pautas de estilo, y si es su proyecto, puede decidir las pautas.

Answer 10

Lo prefiero sin el explícito este puntero también. Para llamadas de método, no agrega mucho valor, pero ayuda a distinguir las variables locales de las variables de miembro.

Answer 11

Esto se ha pedido un par de veces, pero es difícil buscar porque "esto" parece ser la palabra de parada para la búsqueda.

Aquí es mi propia pregunta: Are there any reasons not to use "this" ("Self", "Me", ...)?

Answer 12

Esto se hace para ser explícito sobre el hecho de que la variable que se utiliza es una variable miembro en contraposición a una variable local o global. No es necesario en la mayoría de los casos, pero ser explícito sobre el alcance podría ser útil si ha superado la variable con una declaración del mismo nombre en un ámbito más estricto.

En las empresas en las que he trabajado, sólo antepone "m_" a variables miembro. A veces puede ser útil, y prefiero usar "this->".

Editando: Añadiendo un enlace a the GCC docs, que explica un caso donde usar this-> es necesario para que una búsqueda no dependiente funcione correctamente.

Answer 13

El único lugar en el que realmente hace la diferencia está en las plantillas en las clases derivadas:

template<typename T> 
class A { 
protected: 
    T x; 
}; 

template<typename T> 
class B : A<T> { 
public: 
    T get() { 
    return this->x; 
    } 
}; 

Debido a details in the name lookup in C++ compilers, tiene que quedar claro que x es un (heredado) miembro de la clase, más fácil de hacer con this->x. Pero este es un caso bastante esotérico, si no tiene jerarquías de clases con plantillas, realmente no necesita usar explícitamente this para acceder a los miembros de una clase.

Answer 14

No puedo recordar bien las circunstancias exactas, pero he visto casos (muy raro) donde tuve que escribir "this-> MemberName" para compilar correctamente el código con GCC. Todo lo que recuerdo es que no estaba relacionado con la ambigüedad y, por lo tanto, me tomó un tiempo encontrar la solución. El mismo código compilado bien sin usar this-> en Visual Studio.

Answer 15

lo voy a utilizar para llamar a los operadores de forma implícita (el retorno y parámetros de los tipos siguientes son sólo maniquíes para la confección del código).

struct F { 
    void operator[](int); 
    void operator()(); 

    void f() { 
    (*this)[n]; 
    (*this)(); 
    } 

    void g() { 
    operator[](n); 
    operator()(); 
    } 
}; 

me gusta la sintaxis *this más. Tiene una semántica ligeramente diferente, ya que usar *this no ocultará las funciones del operador no miembro con el mismo nombre que un miembro.

Answer 16

Hay muchas buenas respuestas, pero ninguna de ellas menciona que usar this-> en el código fuente hace que sea más fácil de leer, especialmente cuando estás leyendo un código de alguna función larga, pero incluso una función corta, imagina un código :

bool Class::Foo() 
{ 
    return SomeValue; 
} 

de mirar en este código, no se puede saber con claridad lo que es SomeValue.Podría ser incluso algunos #define o variable estática, pero si usted escribe

bool Class::Foo() 
{ 
    return this->SomeValue; 
} 

que tener claro que SomeValue es una variable miembro no estática de la misma clase.

Así que no solo ayuda a asegurar que el nombre de sus funciones o variables no entre en conflicto con otros nombres, sino que también hace que sea más fácil para otros leer y comprender el código fuente, escribiendo una auto documentación el código fuente a veces es muy importante también.

Answer 17

Otro caso, que ha llegado a las escenas después de C++ 11 está en lambdas donde se captura this.

Es posible que tenga algo como:

class Example 
{ 
    int x; 
public: 
    std::function<void()> getIncrementor() 
    { 
    return [this]() -> void 
    { 
     ++(this->x); 
    } 
    } 
}; 

Aunque se genera el lambda dentro de una clase, sólo tendrá acceso a las variables locales mediante la captura de ellos (si su compilador C++ 14) o la captura de this . En el segundo caso, dentro del cuerpo de lambda, simplemente no está x, sino solo this->x.