Foro de elhacker.net

Hola..

haciendo algunos ensayos, me he encontrado con una sorpresa, cuando intento utilizar algún operador sobrecargado con un tipo propio, se ejecuta el constructor y el destructor al instante.... ej:

 
struct x{
 
private:
     int a;
 
public:
     x(){ std::cout << "Constructor ejecutado."; }
     ~x() { std::cout << "Deconstructor ejecutado."; }
     inline void setA(const int _a){ this->a = _a; }
     inline int getA() const { return this->a; }
}
 
std::ostream operator <<(std::ostream & _os, const x _x){
     _os << _x.getA();
     return _os;
}
 
 
 
int main(){
 
     x typeX;    //Constructor llamado como es usual..
     std::cout << x;     //Constructor y deconstructor llamados, por que?
 
}
 
 
 

El destructor se llaman cuando se destruye un objeto.
Al usar el return, el objeto(variable de la clase) _os se va fuera de scope(alcance) asique se llama al destructor automáticamente tras el return.
Pd: Disculpa, es el puntero this lo que se retorna con el objeto y se sale de scope.

Te he subido un pastebin con la traducción que hice del capitulo 8 del libro Apress learn cpp for game development que va de POO en la aue se explica y más cosas.
https://pastebin.com/jcg3yzEn

No compila con facilidad ese codigo pero bueno, la clave es que se crea un objeto temporal del tipo x (no ostream, el que tiene el cout en el constructor y destructor no es ostream precisamente) por una razon: estas pasando x por valor. Pasalo como referencia y no se creara mas:

std::ostream &operator <<(std::ostream & _os, const x & _x)

Ese ejemplo tuyo y lo que te comenta Eternal Idol es la razón por la que se suele recomiendar pasar los objetos por referencia, ya que así se evita la creación de copias temporales.

Sin embargo, en tu código, la línea 24 no invoca al constructor que tú escribiste, ya que se trata del constructor por defecto (sin parámetros). Ese sólo se llama cuando creas un objeto como en la línea 23. En la línea 24, como te indicaron, se está copiando un objeto, por lo que se invoca al constructor de copia de x. Tú no escribiste uno, por lo que el compilador lo hace por ti y es ése el que es llamado. Por eso, al ejecutar tu programa, deberías ver sólo un mensaje de " constructor ejecutado" y dos del destructor.

En este programa x en minuscula es el tipo, no es el nombre de una variable, de modo que tiene que haber 2 constructores pues hay 2 objetos distintos creados aqui.

Tal cual esta el fragmento (y sin tener en cuenta el faltante de cabeceras) no compila (la estructura no termina con un };, la sobrecarga si es interna necesita de friend, el valor de retorno de la sobrecarga debe ser una referencia y finalmente x es una estructura y lo que quiere empujar en cout es la variable que acaba de definir) pero segun la descripcion no es el caso, simplemente un typo.

Vaya si, me he equivocado al replantear el ejemplo, debi reemplazar x por typeX al final en el cout...


Bueno, comentar que he pasado el argumento por referencia y ahí no me ejecutó el constructor....  lo cual ahora que lo veo bien si es lógico..

de repente es algo confuso saber cuando retornar una referencia o una copia y cuando aceptar un argumento como referencia o como copia en los operadores sobrecargados...

gracias por la ayuda..

Mirate el link que te pasé que ahí te viene.

Si, gracias, Lo veo.