SoloCodigo

Programación General => C/C++ => Mensaje iniciado por: krnl64 en Miércoles 21 de Julio de 2010, 17:55

Título: Duda Destructores C++
Publicado por: 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 (http://www.parashift.com/c++-faq-lite/dtors.html" onclick="window.open(this.href);return false;)  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

Título: Re: Duda Destructores C++
Publicado por: r0d en Miércoles 21 de Julio de 2010, 19:03

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  :(

Título: Re: Duda Destructores C++
Publicado por: ivancp en Miércoles 21 de Julio de 2010, 19:10

Hola,

Solo para probar tu pregunta, escribi el codigo siguiente:

Código: C++

1. #include <iostream>
2. using namespace std;
3. class Member
4. {
5.     string name ;
6.     public:
7.         Member(const char *n = "default")
8.         {
9.             name = n;
10.             cout<<"Member "<<name<<" init"<<endl;
11.         }
12.         ~Member()
13.         {
14.             cout<<"Member "<<name<<" destroy"<<endl;
15.         }
16. };
17.  
18. class A
19. {
20.     Member m1;
21.     Member *m2;
22.     public:
23.     A()
24.     {
25.         m2 = new Member("dynamic");
26.         cout<<"A class init"<<endl;
27.     }
28.     ~A()
29.     {
30.         cout<<"A class destroy"<<endl;
31.     }
32. };
33.  
34. int main(int argc, char *argv[])
35. {
36.     A a;
37. }
38.  

El resultado es:

Código: Text

1. ivancp@ivancp-ubuntu:~/projects/source$ ./destructor
2. Member default init
3. Member dynamic init
4. A class init
5. A class destroy
6. Member default destroy
7.  

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++

1.     ~A()
2.     {
3.         delete m2;
4.         cout<<"A class destroy"<<endl;
5.     }
6.  
7.  

Saludos.

Título: Re: Duda Destructores C++
Publicado por: krnl64 en Miércoles 21 de Julio de 2010, 19:43

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++

1.  
2. class linkedlist
3.     {
4.    
5.         public:
6.        
7.             linkedlist(void); // default constructor
8.                
9.             ~linkedlist(); // destructor
10.            
11.              const bool insert ( const int value ); // insert element                                          
12.    
13.         private:
14.        
15.             struct node
16.             {
17.                 int value;  // node struct
18.                 node* next;
19.             }; 
20.            
21.             int elements;     // amount of elements
22.             node* firstnode; // first node
23.                                
24.     };
25.  
26.  

codigo:

Código: C++

1.  
2. // insert element
3. const bool linkedlist::insert (const int value)
4. {
5.  
6.     node* newnode = NULL;
7.     node* lastnode = NULL;
8.    
9.    
10.            
11.         newnode = new node; // alloc new node
12.        
13.         if ( !newnode ) return false; // if new fails
14.        
15.         newnode->value = value; // asign value
16.         newnode->next = NULL;   // init next element
17.    
18.         if ( this->elements == 0) // there is no nodes
19.                
20.             this->firstnode = newnode; // assign first node
21.        
22.         else
23.         {
24.        
25.             lastnode = this->firstnode;
26.                                                 // goto last node
27.             while (lastnode->next)
28.                 lastnode = lastnode->next; 
29.                
30.             lastnode->next = newnode;   // set new node as next node
31.         }
32.        
33.         this->elements++; // update node count
34.        
35. return true;
36. }
37.  
38. // destructor
39. linkedlist::~linkedlist()
40. {
41.  
42.     node* currentnode = NULL;
43.     node* nextnode = NULL;
44.    
45.  
46.         if (this->elements > 0) // list has nodes
47.         {
48.             currentnode = this->firstnode;  // get first node
49.            
50.             while ( currentnode ) // while has nodes
51.             {
52.            
53.                 nextnode = currentnode->next; // get next node
54.                
55.                 delete currentnode;
56.                 currentnode = NULL; // delete node
57.                
58.                 currentnode = nextnode; // update current node
59.             }
60.            
61.             this->firstnode = NULL;
62.             //this->elements = NULL; ----> innecesario
63.         }
64.        
65. return;
66. }
67.  
68.