pregunta relativa a "este" puntero en C++

Question

Se me ha dado clase con variables int x e y en privado, y una función de sobrecarga del operador,

class Bag{ 
private: 
    int x; 
    int y; 
public: 
    Bag(); 
    ~Bag(); 
    //....... 
    //.....etc 
}; 


Bag operator+ (Bag new) const{ 
    Bag result(*this); //what does this mean? 
    result.x += new.x;   
    result.y += new.y; 
} 

¿Cuál es el efecto de tener "número Bolsa (* este); ¿ahí?.

Answer 1

crea una copia del objeto al que se llamó la función del operador.

Ejemplo si había:

sum = op1 + op2; 

entonces result habrá una copia de op1.

Dado que la función operator+ está haciendo una suma de sus operandos y devolver la suma, necesitamos una manera de acceder a la OP-1 de operando que se realiza a través del puntero this.

Alternativamente podríamos haber hecho:

Bag result; 
result.x = (*this).x + newobj.x; // note you are using new which is a keyword. 
result.y = (*this).y + newobj.y; // can also do this->y instead 
return result; 

Answer 2

La función devuelve una copia operator+. La declaración:

Bag result(*this); 

está haciendo una copia de este objeto para volver a la persona que llama. Según la firma, debe devolver un valor, por lo que está haciendo una copia y luego agrega el objeto new.

Answer 3

En primer lugar, indique al escritor de códigos que no use new como nombre de la variable, es una palabra clave. Además, recuerda al return result;. Y pase por const-reference o modifique directamente la bolsa new.

---

Dentro de una estructura/clase, this es un puntero a sí mismo. Por lo tanto, *this es una referencia a toda la instancia de Bag en sí.

La declaración Bag result(a_bag_reference) llamará al constructor de copia de Bag, lo que hace una copia de a_bag_reference en result.

Por lo tanto,

Bag result(*this); 

hace una copia de sí mismo, a continuación, almacenar en result. Esto hace que los próximos 2 declaraciones

result.x += new.x; 
result.y += new.y; 

no afectan a la instancia en sí (es decir this->x y this->y se mantienen constantes).

Answer 4

Su código se vería así:

class Bag { 
public: 
    Bag(); 
    Bag(Bag const& other); // copy ctor, declared implicitly if you don't declare it 
    ~Bag(); 

    Bag operator+(Bag const& other) const; 

private: 
    int x; 
    int y; 
}; 

Bag Bag::operator+(Bag const& other) const { 
    Bag result (*this); 
    result.x += other.x;   
    result.y += other.y; 
    return result; 
} 

El "objeto actual" implícita para las funciones miembro se ha apuntado por un valor especial llamado este.Entonces *this obtiene ese objeto (desreferenciando este), y se usa para construir (mediante el constructor de copia) otra bolsa llamada resultado.

Sospecho que este código se toma de una tarea, por lo que no podría ser capaz de utilizar el patrón one true addition operator, pero es común y que debería ser consciente de ello:

struct Bag { 
    //... 
    Bag& operator+=(Bag const& other) { 
    x += other.x; 
    y += other.y; 
    return *this; // return a reference to the "current object" 
    // as almost all operator=, operator+=, etc. should do 
    } 
}; 

Bag operator+(Bag a, Bag const& b) { 
    // notice a is passed by value, so it's a copy 
    a += b; 
    return a; 
} 

Answer 5

Bag result(*this); es declarar una variable result e invocando su copia constructor.

Puede imaginar que C++ declara automáticamente un constructor de copia predeterminado para todas las clases. Su trabajo es simplemente para inicializar un objeto con otro objeto:

Bag::Bag(Bag const& src) { 
    x = src.x; 
    y = src.y; 
}

La expresión *this puede parecer un poco inquietante, pero es sólo el horror habitual de C++ cuando se trabaja con parámetros &.