SoloCodigo

Hola chavales, ¿qué onda?

Estoy refrescando mi memoria en POO (y de paso aprendiendo la sintaxis de C++ de una vez   ) y he implementado una cola de enteros doblemente enlazada:


El desctructor y el operador + implementados tal que así:


Sin embargo, me da error de violación de segmento en la línea (en main()):


Si imprimo los valores en el interior del operador, la cola this queda con los nuevos valores concatenados de cola, pero al salir del operador y querer imprimirlo en main(), veo que los valores de la cola son todos incorrectos, con punteros corruptos.

Si comento el destructor funciona bien, así que el problema es el destructor, ya que suprime los valores de ambas colas al salir del operador + (porque son variables locales al método). Pero necesito usar el destructor para liberar la memoria usada una vez finalizado el programa, y tampoco quiero que se tenga que llamar a un método de descarga cada vez que se deje de usar una cola, que para eso están los destructores. ¿Alguna idea de cual es el error?

¡Gracias de antemano!

Hmmm, pero las colas funcionan perfectamente si dejo sólo el destructor por defecto (el que no hace nada, vamos).

Aquí te dejo el constructor y los métodos de inserción de elementos que uso en main():


Y ya que estamos, main():

Sí , claro, no hay problema en pasarte el código completo, sólo estoy frikeando con él  

P.D: Uso VC++. Las tripas del destructor están comentadas.

A mi no me ha dado error ninguno :S Solo me decia que lo de hacerse amigo a si mismo estaba implicito... que no hace falta ponerlo. Por lo demas todo bien. Por cierto deja una linea en blanco al final del fichero. Da errores raros luego.

Solo decirte que yo uso el eclipse con MinGW.

Precisamente, si los paso por valor, ¿por qué los devuelve modificados?  

cola3 = cola1 + cola2;

es lo mismo que:
cola3.operator=(cola1.operator+(cola2));

al no estar el operador = sobrecargado nos podemos quedar con:
cola3  = cola1.operator+(cola2);

entonces vamos al operador + que termina asi:
return *this;

por lo tanto esto se reduce a (despues de la suma):
cola3 = cola1;

PERO cola1 (ahora es en realidad la variable cola del operador) es una copia TEMPORAL que desaparece al terminar el operador, por eso si no ejecutas el destructor no se destruye la memoria.

Si pones un cout << "destructor" endl; en el destructor vas a ver que se lo llama 5 veces, 2 por la copia y tres por las variables del main. Despues de llamarse al destructor por las copias lo que asigne a cola3 ya no es valido  

Como te decia antes simplemente cambiando la signature del operador solucionas el problema:

cColaEnteros &operator + (cColaEnteros &cola);

cColaEnteros &operator + (cColaEnteros &cola)
{
//tu codigo actual
}

No hay ningún cambio al ponerlo así, Eternal Idol.

Aquí la tienes comentada, EL_UNI

1. Compilo y ejecuto, sale el output de arriba.
2. Descomento el destructor, salen numeros hasta que me canso y le doy a ctrl+c.
3. Agrego las referencias mencionadas, sale el output de arriba.

Pues a mí no me funciona así... Yo también me lo he tenido que bajar de aquí mismo porque lo hice en otro PC.

Con el destructor, no funciona ni como lo puse yo ni con el operador de dirección (&) que has comentado.

Aquí está el error:

[attachment=0:1ff37riq]captura18-10-08.JPG[/attachment:1ff37riq]

Debido a que las referencias a memoria están mal y por tanto el acceso a la memoria aux->valor no está permitido.

EDIT: Ahora que lo pienso, es posible que a ti te salgan los números raros porque te accede a una memoria accesible por tu proceso, y en el mío no, ya que los valores que pueden tomar las referencias erróneas diferirán en cada PC.

Sí, tienes razón, sí que funciona mejor con el & (no sé cómo demonios lo puse antes  ), pero da otro error de puntero corrupto al ejecutar el destructor de cola3 (sé que es cola3 porque primero pasa por cola1 y cola2):
[attachment=0:29zbsbz5]captura2.JPG[/attachment:29zbsbz5]

Creo que sé lo que pasa.

Haciendo una inspección, me doy cuenta de que cola1 y cola3 hacen referencia a la misma memoria, por tanto al destruirse cola3 se destruye también cola1, pero luego se vuelve a llamar al destructor de cola1, con el consiguiente desastre. El problema supongo que vendrá del operador = que no está definido para esta clase. Voy a crearlo y te sigo comentando.

Por cierto, ¡gracias Eternal Idol!

EDIT: en realidad habría que cambiar el operador + también. Me estoy dando cuenta de lo mal hecho que está...  

Mierda, funciona pero tiene un memory leak de esta manera, nadie llama a delete por este new: aux = new cColaEnteros;.

Todos los ejemplos que encuentro devuelven por VALOR (usando un objeto temporal!       ) y ninguno parece funcionar en este caso ya que como vimos el destructor es llamado al terminar el operador y los valores son basura desde ese momento en adelante.

Si usaras punteros no habria problema  

Un hack para que funcione usando como decias el operador =:

O tambien en combinacion con el operador = usar un constructor especial con un parametro tipo allocatedMemory a true en el operador + y comprobar eso en el destructor antes de llamar a Esta_Vacia, creo que la STL hace algo parecido a esto.

Igual no me cierra el tema todavia ...

¿Cómo no? Ese objeto se asigna a la vuelta de la función (en este caso a cola3) y se llama a su destructor. ¿O me estoy equivocando?

Eso (casi, el delete obviamente es manual) pasaria si cola3 fuera un puntero, como NO lo es, simplemente se asigna un puntero (pCabecera) pero cola3 siempre apunta a la misma direccion de memoria en la pila.

EDIT: efectivamente, la depuración dice que sí se destruye. Es la misma dirección de memoria (del pCabecera) la que se la asigna a aux en el operador que a la hora de destruir cola3. ¡Por fin!

Nopes, ciertamente cola3.pCabecera es la misma direccion que paux = this->pCabecera pero cola3 (&cola3 si queres) no es la misma que aux = new cColaEnteros;. Para comprobarlo experimentalmente lo que hice fue sobrecargar new y delete en la clase ... se llama a un new y nunca a delete. Tene en cuenta que el destructor de cColaEnteros se llama por cola1, cola2 y cola3, jamas para el objeto creado dinamicamente (otra cosa es que este objeto, cola3, comparta campos - punteros - que son liberados con el objeto creado dinamicamente, pero no es suficiente para liberar el objeto en si mismo). Una forma de solucionarlo simple pasa por liberar ese objeto en el operador de asignacion, por ejemplo de esta otra manera:


Puede que me confunda pero creo que al final lo que hace la STL es algo asi, devolviendo por valor y marcando la no destruccion interna (nos olvidamos de new, delete y el operador =):

Está saliendo un código un poco lioso, no es más fácil implementarle una función a la clase para que concatene dos colas pasadas como parametros?

Puede ser pero tal vez la gracia es usar sobrecarga de operadores ...

Una pregunta... porque no usais varios archivos... lo introducis todo en un mismo .cpp. Es mucho mejor y más cómodo luego revisar código si los separas en cabeceras (.h) y código (.cpp). En mi caso tengo colaIntDoble.h, colaIntDoble.cpp y main.cpp. Es solo por comentar... no reprocho nada xDDD

Ciertamente es preferible modularizar el codigo pero para resolver este problema es irrelevante (y cuantos menos archivos haya que subir/bajar de la red mejor).