Pregunta En una clase de C ++, ¿cuál es la diferencia entre acceder a una variable miembro con "esto"


Hice una clase simple para representar una puerta. Para devolver las variables, las estoy accediendo con el this puntero. Con respecto al mero acceso a las variables, ¿cuál es la diferencia entre acceder a ellas con el this puntero y sin?

class Door
{
protected:
    bool shut; // true if shut, false if not shut
public:
    Door(); // Constructs a shut door.
    bool isOpen(); // Is the door open?
    void Open(); // Opens the door, if possible. By default it
    // is always possible to open a generic door.
    void Close(); // Shuts the door.
};
Door::Door()
{}
bool Door::isOpen()
{
    return this->shut;
}
void Door::Open()
{
    this->shut = false;
}
void Door::Close()
{
    if(this->isOpen()) this->shut = true;
}

Puede o no haber una diferencia aquí, pero ¿qué pasa con las clases más complejas?


5
2017-11-03 21:51


origen


Respuestas:


Nada. los this el puntero se agrega automáticamente si lo excluye.

Solo tienes que usarlo si estás haciendo algo como esto:

void Door::foo(bool shut)
{
    this->shut = shut; // this is used to avoid ambiguity
}

Más usos


Una breve reseña:

Piense en los métodos como funciones que pasan un puntero como su primer argumento.

void Door::foo(int x) { this->y = x; } // this keyword not needed

es más o menos equivalente a

void foo(Door* this_ptr, int x) { this_ptr->y = x; }

Los métodos simplemente automatizan esto.


10
2017-11-03 21:53



No hay diferencia

Cuando escribes sane C ++, no deberías tener que decir this en absoluto excepto en situaciones muy específicas. (Los únicos en los que puedo pensar son los punteros a la función miembro, pasando el puntero de instancia a algún otro objeto, y algunas situaciones involucrando plantillas y herencia (gracias a Mooing Duck por el último ejemplo).

Solo proporcione a su función argumentos y variables locales y nombres de variables de miembros de manera que no tenga ambigüedades.

Hay un montón de lenguajes más recientes orientados a objetos que han hecho que las palabras "este" y "nuevo" sean casi sinónimo de "estoy usando objetos" para las generaciones más jóvenes, pero ese no es el lenguaje C ++.


3
2017-11-03 21:59



En tu caso no hay diferencia. Sólo más trabajo de mecanografía.


1
2017-11-03 21:58



Todo esto parece ser un ejercicio de tipificación superflua. Por lo que puedo ver, Close se puede condensar a:

void Door::Close() {
    shut = true; 
}

Hacer la tarea incluso cuando no es necesaria es mucho más simple que probar y configurar solo si es actualmente falso.

También vale la pena mencionar (IMO) que este comentario:

Door(); // Constructs a shut door.

No parece ajustarse a la implementación:

Door::Door()
{}

Si desea que el ctor predeterminado se inicialice shut a true, necesita / desea agregar un código para hacer eso.

Peor, tu IsOpen parece hacer las cosas exactamente al revés:

bool Door::isOpen()
{
    return this->shut;
}

Si está cerrado, es no Abierto, y viceversa.


1
2017-11-03 22:33



No hay diferencia, excepto más tipo y el ruido introducido por this->.

void Door::Close()
{
    if(isOpen()) shut = true;
}

Es más legible para ellos esto:

void Door::Close()
{
    if(this->isOpen()) this->shut = true;
}

Pero eso es solo una preferencia personal, y una cuestión de estilo.


0
2017-11-03 22:08