SoloCodigo

¡Saludos!
Antes que nada, cuando declaro atributos privadas les coloco un "underscore" ('_') delante. Sólo lo hago para tener en cuenta que son privados. He visto códigos que utilizan uno, o dos seguidos, y no sé por qué lo hacen. ¿Existe alguna razón en particular para utilizarlas en los nombres de atributos y funciones?
Mi otra duda es que cuando uno declara un destructor, ¿debe codificar como destruir el objeto?, ¿o el programa lo hace solo?
Por ejemplo, parte de un código es el siguiente:


¿Ese destructor debe llevar algún código para liberar la memoria?
¿Cómo lo llamo en el código principal para que destruya a un objeto?

¡Gracias de antemano!

En mi caso le agrego un underscore posterior al nombre, en el caso de lo(s) parametro(s) de una funcion, y doble underscore a los metodos de la clase para distinguirlos.

Tambien lo hago por estilo y evitar repetir en algun caso el nombre de las variables.

El doble underscore previo al nombre, tengo entendido que son para funciones o variables de muy bajo nivel p.e:

Cita de: "chuidiang"

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;
}