SoloCodigo

Programación General => C/C++ => Mensaje iniciado por: _.B._ en Lunes 5 de Junio de 2006, 07:13

Título: Destructor. Underscore.
Publicado por: _.B._ en Lunes 5 de Junio de 2006, 07:13
¡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:

Código: Text
  1. class C_BitMap {
  2.     private:
  3.     uShort _arTipo;
  4.     uLong  _arTam;
  5. ...
  6.     uLong  _imAncho;
  7.     uLong  _imAlto;
  8. ...
  9.     uChar _vectorBmp[maxPixeles];
  10.  
  11.     public:
  12.         // Constructor del Objeto a partir de un archivo bitmap.
  13.         C_BitMap(const char in[]) {
  14.             cargaArchivoBitMap(in);
  15.         }
  16. ...
  17.         // Destructor.
  18.         ~C_BitMap() {}
  19. ...
  20.  

¿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!
Título: Re: Destructor. Underscore.
Publicado por: chuidiang en Lunes 5 de Junio de 2006, 22:11
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.
Título: Re: Destructor. Underscore.
Publicado por: shakka en Lunes 5 de Junio de 2006, 22:25
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:

Código: Text
  1. __fpurge(stdin);
  2.  
Título: Re: Destructor. Underscore.
Publicado por: chimps en Lunes 5 de Junio de 2006, 23:14
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?
Título: Re: Destructor. Underscore.
Publicado por: Amilius en Martes 6 de Junio de 2006, 04:08
Cita de: "chimps"
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 ,

   return 0;
}
Título: Re: Destructor. Underscore.
Publicado por: _.B._ en Martes 6 de Junio de 2006, 05:17
¡Saludos!
¡Chuidiang, Mbrenes, Amilius, gracias a todos por las respuestas y ejemplos!
Me han servido de mucho :smartass:
¡Sigan posteando!
¡A programar! :comp: