Programación General > C/C++

 Duda Destructores C++

(1/1)

krnl64:
Hola, tengo un par de dudas acerca del comportamiento de los destructores.

Mirando http://www.parashift.com/c++-faq-lite/dtors.html  punto 11.11

dice que cuando cuando se destruye un objeto se llama automáticamente a los destructores de los miembros de los que esta compuesto.
Se refiere a los miembros que no son punteros  ?
Que ocurre si en el destructor pongo las variables miembro a su valor por defecto entonces ? ( por ejemplo pongo un entero a 0 o a NULL)

Editado : ya vi el fallo del code de antes

 A ver si me pueden esclarecer el tema un poco Gracias

r0d:
Hola,

lo que pasa, es que hay que ver un puntero como un objeto en si mismo. Es un objeto que contiene la dirección de otro objeto.
Entonces, si tienes un puntero en variable miembra de tu clase, el destructor estara llamado, pero solo el puntero estara destruido, y no el objeto apuntado por el puntero.
Para destruir el objeto apuntado por el puntero, hay que llamar al operador delete (que no es un destructor, sino un operador que llama al destructor del objeto apuntado, no es lo mismo).
Entonces, si tienes un puntero en variable miembra, hay que llamar al delete dentro de tu destructor, sino el objeto dicho no es destruido.

Espero que me explico.


--- Citar ---Que ocurre si en el destructor pongo las variables miembro a su valor por defecto entonces ? ( por ejemplo pongo un entero a 0 o a NULL)
--- Fin de la cita ---
Perdon pero no entiendo esta pregunta  :(

ivancp:
Hola,

Solo para probar tu pregunta, escribi el codigo siguiente:


--- Código: C++ ---#include <iostream>using namespace std;class Member{    string name ;    public:         Member(const char *n = "default")        {            name = n;            cout<<"Member "<<name<<" init"<<endl;        }        ~Member()        {            cout<<"Member "<<name<<" destroy"<<endl;        }}; class A{    Member m1;    Member *m2;    public:    A()    {        m2 = new Member("dynamic");        cout<<"A class init"<<endl;    }    ~A()    {        cout<<"A class destroy"<<endl;    }}; int main(int argc, char *argv[]){    A a;} 
El resultado es:


--- Código: Text ---ivancp@ivancp-ubuntu:~/projects/source$ ./destructor Member default initMember dynamic initA class initA class destroyMember default destroy 
En conclusion: Cuando la clase contenedora se destruye, tambien llama a los destructores de los miembros no punteros, por que si lo hiciera sería un gran problema para las referencias a otras clases y demas artificios que solemos hacer con los punteros, por lo que no es una falla sino una ventaja por que nos permite tener el control total del codigo que escribimos.

Para controla la variable Member *m2 , es necesario liberar la memoria de dicha variable en el destructor de la clase contenedora, de tal modo que queda asi:


--- Código: C++ ---    ~A()    {        delete m2;        cout<<"A class destroy"<<endl;    }  Saludos.

krnl64:
r0d,  ivancp dio en clavo, gracias de todas maneras.
No obstante, me referia a que la linea 62 de codigo es innecesaria porque se supone el sistema la eliminara sola

Gracias por todo chicos

interface:

--- Código: C++ --- class linkedlist    {            public:                    linkedlist(void); // default constructor                            ~linkedlist(); // destructor                         const bool insert ( const int value ); // insert element                                                       private:                    struct node            {                int value;  // node struct                node* next;            };                          int elements;     // amount of elements            node* firstnode; // first node                                    };  
codigo:

--- Código: C++ --- // insert elementconst bool linkedlist::insert (const int value){     node* newnode = NULL;    node* lastnode = NULL;                            newnode = new node; // alloc new node                if ( !newnode ) return false; // if new fails                newnode->value = value; // asign value        newnode->next = NULL;   // init next element            if ( this->elements == 0) // there is no nodes                            this->firstnode = newnode; // assign first node                else        {                    lastnode = this->firstnode;                                                // goto last node            while (lastnode->next)                lastnode = lastnode->next;                              lastnode->next = newnode;   // set new node as next node        }                this->elements++; // update node count        return true;} // destructorlinkedlist::~linkedlist(){     node* currentnode = NULL;    node* nextnode = NULL;             if (this->elements > 0) // list has nodes        {            currentnode = this->firstnode;  // get first node                        while ( currentnode ) // while has nodes            {                            nextnode = currentnode->next; // get next node                                delete currentnode;                currentnode = NULL; // delete node                                currentnode = nextnode; // update current node            }                        this->firstnode = NULL;            //this->elements = NULL; ----> innecesario        }        return;}  

Navegación

[0] Índice de Mensajes