Autor Tema: Duda Destructores C++ (Leído 1878 veces)

krnl64 · « **en:** Miércoles 21 de Julio de 2010, 17:55 »

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)

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 init
Member dynamic init
A class init
A class destroy
Member 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 element
const 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;
}
 
// destructor
linkedlist::~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;
}
 
 

SoloCodigo

Autor Tema: Duda Destructores C++ (Leído 1878 veces)

krnl64

Duda Destructores C++

r0d

Re: Duda Destructores C++

ivancp

Re: Duda Destructores C++

krnl64

Re: Duda Destructores C++