Cosa De C++

[Pogacha]

 Seguid el ejemplo:

Código [Seleccionar] Expand

class TCosa
{
   TObjetoInterno *OI;

public:

  TCosa(const TObjetoInterno *o = NULL);
  ~TCosa();

  TCosa  operator+(const TCosa &c) const;

  TObjetoInterno *Tomar_ObjetoInterno() const;
};


TObjetoInterno *TCosa::Tomar_ObjetoInterno() const
{
  return OI;
}


TCosa::TCosa(const TObjetoInterno *o)
{
  OI = o;  // es un mal diseño, pero supongamos para que valga el ejemplo
}

TCosa::~TCosa()
{
 if(OI)  delete OI;
}

TCosa TCosa::operator+(const TCosa &c) const
{
  TObjetoInterno *NO = new TObjetoInterno;

  NO->FuncionSuma(OI, c.OI);

  return TCosa(NO);  // Esto es lo que no anda :( , me destruye el objeto antes de pasarlo
}


void main(void)
{
  TCosa a(new TObjetoInterno);
  TCosa b(new TObjetoInterno);
  TCosa c;

  c=a+b;             // esto es lo que no me funciona ...
  c->Tomar_ObjetoInterno()->FuncionHola();    // me termina dando error de proteccion de memoria

}


Como hago para que esto funcione ?
O sea devolver un objeto en una función y que no lo destruya antes?
Nesesito esta funcionalidad ...

Saludos.

[ProD]

 Buenas, ¿Has probado a tener un constructor copia?, quizás te interesaría también tener un
operador de asignación. Saludos

[zupervaca]

 

return TCosa(NO);  // Esto es lo que no anda :( , me destruye el objeto antes de pasarlo

el objeto NO no te lo puede destruir ya que lo has creado con new y el objeto TCosa lo esta devolviendo y el lenguaje no lo puede destruir con lo que el fallo no puede estar ahi

por ejemplo yo tengo esto en mi clase vector3

Código [Seleccionar] Expand

  __forceinline Vector3 Vector3::operator+ ( Vector3 &v )
  {
   return Vector3( x+v.x, y+v.y, z+v.z );
  }

[CoLSoN2]

 Normal que te pete.

Lo que ocurre es,

En operator+:
- Se crea un objeto dinámico "NO". Para que se borre deberías hacerlo manualmente usando delete.
- Luego creas un objeto estático en el return, y asignas "NO" a él. Este objeto sí será borrado después de _copiarse_ a la variable "c" (en la línea c = a+b;). Al copiarse, el TObjetoInterno* "NO" se comparte entre ambos, porque se igualan los valores de esa variable, que es un puntero.
- Al borrarse la variable estática que se creó en el return, se libera la memoria de "NO" (en ~TCosa()), por lo que el TObjetoInterno* de la variable "c" deja de apuntar a un bloque de memoria válido.

Solución

Sobrecarga el operador de asignación para TCosa y "clona" el miembro "OI" de la clase. Algo como:

Código [Seleccionar] Expand


TCosa& TCosa::operator=(const TCosa& obj)
{
this.IO = new TObjetoInterno;

// igualar this.IO a obj.IO, aunque lo suyo sería usar un constructor copia
this.IO->miembro = obj->IO->miembro;

return *this;

}


Normalmente, si una clase tiene miembros que son objetos dinámicos (reservas su memoria usando new) querrás sobrecargar el operador de asignación, para que al igualar un objeto de esa clase a otro este objeto no se comparta (si lo cambias o borras en uno de sus padres, también se altera en el otro), sino que se tengan instancias iguales pero independientes.

[zupervaca]

 

OI = o;  // es un mal diseño, pero supongamos para que valga el ejemplo

se supone que el operador = lo tiene como indicas

editado: a pues no, por que tendria que poner el *

[CoLSoN2]

 Si con OI = o lo que realmente está haciendo es clonar el objeto (crear una nueva instancia y copiar los datos del otro), entonces valdría con cambiar

Código [Seleccionar] Expand

TCosa c;
c = a+b;
por

Código [Seleccionar] Expand

TCosa c((a+b).OI);

[zupervaca]

 nos viene ni que pintado este post para otro tema un poco off-topic y es sobre las optimizaciones del compilador, por ejemplo, si en vez de hace esto:

Código [Seleccionar] Expand


TCosa c;
c=a+b;

hacemos esto

Código [Seleccionar] Expand


TCosa c=a+b;

¿el objeto creado en el "return TCosa(NO);" se aprovecha o se crea c y otro mas y luego se llama al operador = ? yo creo que en principio optimizaria haciendo que c sea TCosa(NO), pero tampoco lo he mirado nunca, ¿que pensais? ¿o llama al operador = por si se hacen mas cosas?

editado: partiendo de que el operador = de la clase sea el de por defecto sin redifinir

[CoLSoN2]

 Yo diría que en ningún caso c se "convierte" en el objeto TCosa(NO), siempre se crea y se destruye un objeto estático temporal.

[zupervaca]

 ya, en este codigo es asi, pero si el operador = no estuviera redefinido y estuviera el de por defecto del compilador ¿que ocurriria, optimiza o lo hace como si hubieramos redifinido el operador =?

[ethernet]

 A mi el código no me compila.

Bastaría con poner :

Código [Seleccionar] Expand


TCosa c=a+b;


y todo funcionaría a la perfección y además es lo más óptimo. En tu caso pasa lo que dice Colson. Recomiendo mirar effective c++ para cosas de ese tipo, hay ejemplos de casi todo eso.

[CoLSoN2]

A mi el código no me compila.

Bastaría con poner :

Código [Seleccionar] Expand


TCosa c=a+b;


y todo funcionaría a la perfección y además es lo más óptimo. En tu caso pasa lo que dice Colson.

Si pasa lo que digo yo, ¿por qué no pasa lo mismo en este caso?

[zupervaca]

 entonces si de esta manera funciona "TCosa c=a+b;" comprobamos de que el compilador si optimizaria y no llama al operador = ya que el return TCosa(NO) se convierte en c y el objeto NO no es destruido ya que el objeto devuelto por la funcion no es destruido y no se llama al destructor

[ethernet]

Si pasa lo que digo yo, ¿por qué no pasa lo mismo en este caso?

Pues porque en este caso se contruye el objeto una sola vez.  

[Pogacha]

 

por ejemplo yo tengo esto en mi clase vector3

Código [Seleccionar] Expand

  __forceinline Vector3 Vector3::operator+ ( Vector3 &v )
  {
   return Vector3( x+v.x, y+v.y, z+v.z );
  }

Es claro, eso me andaba al galope, tenia años usandolo, pero cuando quize hacer una clase auxiliar para manejo de texto terminé con este problema ...

El operador copia seria "TCosa& TCosa::operator=(const TCosa& obj);"?

Gracias a todos

Edit :

Recien estoy callendo:

Hasta a+b tengo todo bien, pero cuando paso por el = al no tener un operador copia, el compilador hace una copia de memoria (que seria la copia por defecto) del objeto a+b al c, luego destruye el a+b por que se descarta y ahí pierdo el ObjetoInterno de c ...
OK !!!!
(ole)  (ole)  (ole)
Que bueno que lo entendí !!!!
Estoy re contento, en realidad este problema me venia persiguiendo desde hace años y recién ahora logro agarrarlo ... !!!

Saludos y gracias nuevamente

Edit2:

Para que no digan que estoy loco, releí de nuevo y esto me lo decía colson claramente, aun que no le entendí en la primera lectura ...

En operator+:
- Se crea un objeto dinámico "NO". Para que se borre deberías hacerlo manualmente usando delete.
- Luego creas un objeto estático en el return, y asignas "NO" a él. Este objeto sí será borrado después de _copiarse_ a la variable "c" (en la línea c = a+b;). Al copiarse, el TObjetoInterno* "NO" se comparte entre ambos, porque se igualan los valores de esa variable, que es un puntero.
- Al borrarse la variable estática que se creó en el return, se libera la memoria de "NO" (en ~TCosa()), por lo que el TObjetoInterno* de la variable "c" deja de apuntar a un bloque de memoria válido.

Saludos y gracias por triplicado

[Yoshi.css]

 

Hasta a+b tengo todo bien, pero cuando paso por el = al no tener un operador copia, el compilador hace una copia de memoria (que seria la copia por defecto) del objeto a+b al c, luego destruye el a+b por que se descarta y ahí pierdo el ObjetoInterno de c ...
OK !!!!

Y no solo eso. Si realizas la asignación (=) entre dos objetos, y no tienes definido el constructor de copia, el compilador realiza una copia de un objeto en otro bit a bit. El problema surge cuando trabajas con punteros dentro de la clase, y es que ambos objetos estarían accediendo a la mísma dirección de memoria, lo que supone un problema grave y no deseado.