problema gordo con herencia del destructor

[jaao_death]

bueno, compilen este código y la cuestión estará sobre la mesa:

Código:

  1 #include <iostream>
  2 
  3 class padre{
  4     public:
  5     padre(){
  6         std::cout << "Padre creado" << std::endl;
  7     }
  8     ~padre(){
  9         std::cout << "Padre destruido" << std::endl;
 10     }
 11 };
 12 
 13 class hijo : padre{
 14     public:
 15     hijo(){
 16         std::cout << "Hijo creado" << std::endl;
 17     }
 18     ~hijo(){
 19         std::cout << "Hijo destruido" << std::endl;
 20     }
 21 };
 22 
 23 int main(int argc, char** argv)
 24 {
 25     hijo *p = new hijo();
 26     delete []p;
 27     return 0;
 28 }

POR QUE *#%@¬ SE ME DESBORDA LA MEMORIA?

no entiendo, tal vez tenga mal los conceptos básicos sobre herencia de clases.

datos:

Uso linux, concretamente ubuntu
y compilo con g++:
g++ herencia.cpp
no creo que haga falta más...

[jaao_death]

Bueno, al parecer nadie me ha respondido por ignorancia o porque simplemente no les interesa, pero ya no importa, he solucionado el problema y para los que no sepan, o sean curiosos he de destacar una obviedad para resolver mi problema:

la función delete funciona con punteros, es decir, el argumento requerido es un puntero, en el momento mismo en que declaro <code>delete []p</code> estoy diciendo que borre el elemento correspondiente al puntero p "[]p", pero p es de por sí un puntero, con lo cual lo que en realidad envío es hipotéticamente un puntero a una tabla de punteros "**p" lo cual es una mentira, porque p no apunta a una tabla de objetos "hijo", es aquí, no sé exactamente en que forma, cuando delete desborda la memoria intentando borrar una tabla de punteros a objetos que no existe, y que por tanto no tiene límite.

Declaro que lo dicho anteriormente es una deducción propia, que por falta de fuentes, no he podido confirmar, así que si alguien sabe si esto es falso, que por favor indique el porqué.

gracias a todos y espero que esto les sirva.

[r0d]

Hola,

no entiendo lo que dices, pero tienes que saber algo importantisimo: cuando creas una clase destinada a ser heredida, el destructor de esta clase tiene que ser virtual.

En tu caso:

Código cpp:

class padre{
public:
   padre(){
   std::cout << "Padre creado" << std::endl;
   }
   
   virtual ~padre(){
   std::cout << "Padre destruido" << std::endl;
   }
 

[jaao_death]

No se si sepas exactamente qué son las funciones virtuales, no voy a entrar en el tema, porque según lo visto no me hago entender mucho, la cosa es que para esta herencia en particular lo que menos querría sería que el destructor de la clase base sea virtual.

http://www.zator.com/Cpp/E4_11_2d2.htm <-- para quien quiera saber más acerca de los destructores

[jaao_death]

código último: este ya no presenta problemas

Código:

  1 #include <iostream>
  2 
  3 class padre{
  4     public:
  5     padre(){
  6         std::cout << "Padre creado" << std::endl;
  7     }
  8     ~padre(){
  9         std::cout << "Padre destruido" << std::endl;
 10     }
 11 };
 12 
 13 class hijo : padre{
 14     public:
 15     hijo(){
 16         std::cout << "Hijo creado" << std::endl;
 17     }
 18     ~hijo(){
 19         std::cout << "Hijo destruido" << std::endl;
 20     }
 21 };
 22 
 23 int main(int argc, char** argv)
 24 {
 25     hijo *p = new hijo();
 26     delete p; // antes: delete []p  <-- para borrar punteros a tablas.
 27     return 0;
 28 }