devuelve "esto" en C++?

Question

En Java se puede simplemente return this para obtener el objeto actual. ¿Cómo se hace esto en C++?

Java:

class MyClass { 

    MyClass example() { 
     return this; 
    } 
} 

Answer 1

Bueno, para empezar, no se puede devolver cualquier cosa, desde una función -Volviendo void.

Hay tres maneras de devolver algo que proporciona acceso al objeto actual: por puntero, por referencia, y por valor.

class myclass { 
public: 
    // Return by pointer needs const and non-const versions 
     myclass* ReturnPointerToCurrentObject()  { return this; } 
    const myclass* ReturnPointerToCurrentObject() const { return this; } 

    // Return by reference needs const and non-const versions 
     myclass& ReturnReferenceToCurrentObject()  { return *this; } 
    const myclass& ReturnReferenceToCurrentObject() const { return *this; } 

    // Return by value only needs one version. 
    myclass ReturnCopyOfCurrentObject() const { return *this; } 
}; 

Como se indica, cada una de las tres formas devuelve el objeto actual en una forma ligeramente diferente. Cuál de las dos depende de la forma que necesite.

Answer 2

Debido a que el tipo de retorno es void, es decir .: Usted declara que no devuelve nada. Cambiarlo a myclass* para volver a this cambio myclass & para volver referencia a la clase a través *this.

Answer 3

Una de las principales ventajas de retorno por referencia en clases es la capacidad de funciones de la cadena fácilmente.

Supongamos que su función miembro es multiplicar un miembro particular de su clase. Si el formato de los archivos de cabecera y de fuente para mantener la información de la clase y la definición de la función miembro diferente, entonces: El archivo de cabecera MyClass.h

#ifndef myclass_h 
#define myclass_h 
class myclass{ 
    public: 
    int member1_; 
    double member2_; 

    myclass(){ 
     member1_ =1; 
     member2_ = 2.0; 
    }  

    myclass& MULT(int scalar); 
    myclass* MULTP(double scalar); 
} 
#endif 

el archivo de origen: MyClass.cpp

myclass& myclass::MULT(int scalar){ 
     member1_ *= scalar; 
     return *this; 
} 
myclass* myclass::MULTP(double scalar){ 
     member2_ *= scalar; 
     return this; 
} 

Si inicializa un objeto llamado clase utilizando el constructor por defecto anterior, establece member1_ ​​es igual a 1: Luego, en su función principal, que puede hacer cadenas como:

myclass class; 
class.MULT(2).MULT(4); 

Entonces member1_ ​​ahora sería 8. Por supuesto, la idea podría ser encadenar diferentes funciones, y que alteran los diferentes miembros.

En el caso de que utilice la devolución por el puntero, la primera llamada se debe usar el objeto, y cualquier llamada posterior tratará el resultado anterior como un puntero, por lo tanto

class.MULTP(2.0)->MULTP(3.0);