Hola:
Lo de los underline no sé, supongo que es simplemente un estilo para distinguir privados, asegurarse de que no esté repetido, etc. Que yo sepa no hay ninguna necesidad de hacerlo así, salvo por estilo de codificación.
En cuanto al destructor:
Todas las clases tienen un destructor por defecto. Si la clase no reserva memoria con new (o alloc o cualquier otra variante), no hace falta poner el destructor. El destructor por defecto sabe liberar la clase.
Si la clase hace un new y guarda eso en algún atributo de la clase, hay que hacer un destructor y poner el delete de esa memoria declarada.
Si la clase no reserva memoria, pero abre ficheros u otro tipo de recursos, hay que poner un destructor y cerrar el fichero o lo que sea.
Se bueno.
recien hice el cambio de java a c++ y me quedo una duda...cuando hago delete sobre una instancia de una clase que previamente cree con new, me llama automaticamente al destructor o tengo que hacer los 2 pasos por separado?
Si, efectivamente delete llama al destructor.
Pero para saber exactamente que pasa en multitud de situaciones es mejor utilizar este ejemplo simple, lo tome de algún lado que no recuerdo hace milenios y simplemente lo traduje.
La idea es tener una clase simple que te avise cuando se esta creando una nueva instancia, o cuando se está destruyendo una.
A continuacion parte del ejemplo que corre en visual studio, tenemos el Bert.h, el Bert.cpp y un Consola1.cpp donde está el main y varias operaciones de creación de este objeto de diversas formas. La idea es saber exactamente que pasa cuando haces una u otra operación.
Bert.h
******
#include <string>
using namespace std;
class Bert {
public:
Bert();
Bert(char * un_nombre,char * un_contenido);
~Bert();
void agregar_bert();
void cambiar_nombre(char * un_nombre);
string get_string();
protected:
string contenido,nombre;
};
Bert.cpp
********
#include "stdafx.h"
Bert::Bert(char *un_nombre, char *un_contenido)
{
printf("%s: Creando un nuevo Bert (%s)\n",un_nombre, un_contenido);
nombre = un_nombre;
contenido = un_contenido;
}
Bert::Bert()
{
nombre = "Sin Nombre";
contenido = "Sin Contenido";
printf("%s: Creando un nuevo Bert (%s)\n",nombre.c_str(), contenido.c_str());
}
Bert::~Bert()
{
printf("%s: Destruyendo un Bert (%s)\n",nombre.c_str(), contenido.c_str());
}
void Bert::agregar_bert()
{
contenido += " Bert";
printf("%s: Agregando Bert (%s)\n",nombre.c_str(), contenido.c_str());
}
void Bert::cambiar_nombre(char * un_nombre)
{
printf("%s: Cambiando nombre de '%s'\n", un_nombre, nombre.c_str());
nombre = un_nombre;
}
string Bert::get_string()
{
return contenido;
};
Consola1.cpp
***********
#include "stdafx.h"
Bert* a()
{
//Bert b1("b1","Cat");
//b1.agregar_bert();
//return b1;
Bert *un_bert = new Bert("*un_bert","Raton");
return un_bert;
}
void agregar_2bert(Bert &un_bert)
{
printf("agregar_2bert(Bert &un_bert)\n");
un_bert.agregar_bert();
un_bert.agregar_bert();
}
void agregar_2bert(Bert *un_bert)
{
printf("agregar_2bert(Bert *un_bert)\n");
un_bert->agregar_bert();
un_bert->agregar_bert();
}
void agregar_2bert_casoR(Bert *(&un_bert))
{
printf("agregar_2bert_casoR(Bert *(&un_bert))\n");
un_bert->agregar_bert();
un_bert->agregar_bert();
}
void agregar_2bert_casox(Bert un_bert)
{
printf("agregar_2bert_casox(Bert un_bert)\n");
un_bert.agregar_bert();
un_bert.agregar_bert();
}
int main(int argc, char* argv[])
{
Bert s3;
Bert s1("s1","Dog");
Bert s2 = s1;
s2.cambiar_nombre("s2");
agregar_2bert(&s1);
agregar_2bert(s1);
//agregar_2bert_casox(s2);
//agregar_2bert_casoR(t);
Bert *s4=a();
agregar_2bert(*s4);
agregar_2bert(s4);
Bert **t;
t=&s4;
(*t)->agregar_bert();
printf("El nuevo Bert (*s4): %s\n",s4->get_string().c_str());
delete s4;
printf("Valor de s4: %i\n",s4);
s4=NULL;
delete s4;
char * cadena1 = "TES\0T";
printf("Cadena: %s ,
- : %i, [1]: %i, [2]: %i, [3]: %i, [4]: %i, [5]: %i\n",cadena1,cadena1[0],cadena1[1],cadena1[2],cadena1[3],cadena1[4],cadena1[5]);
return 0;
}
Mostrar Mensajes
zwd2000 tiene que explicar mejor... 
¿Como puede saturar la memoria?
Imagínate lo que pasaría si el algoritmo sería más complicado...
