Foro de elhacker.net

Programación => Programación C/C++ => Mensaje iniciado por: DarkSorcerer en 28 Septiembre 2013, 23:05 pm


Título: Lista enlazada, eliminando todos los nodos en C++ (¿ Estara bien ?)
Publicado por: DarkSorcerer en 28 Septiembre 2013, 23:05 pm
Solo hago esta pregunta para saber si esta bien, ya que soy novato aun, cree una lista enlazada simple, utilizando punteros para apuntar al nodo siguiente, utilizando POO.

El esquema de la lista es la siquiente

Head
  l
 \/
 O - O - O - ......................... - O - O - O - NULL

Ahora, cada vez que creo un nodo, lo hago de manera dinamica, sabiendo que no solamente debo borrar la lista cuando termine, si no tambien debo borrar todos los nodos de manera manual, pero no se si estara bien mi forma de borrar.

Todo funciona bien, pero no se si el metodo de eliminacion estara bien , mi objetivo es que se libere todo, y no queden en la memoria cuando termine el programa.

Código
  1. #ifndef LISTA_H
  2. #define	LISTA_H
  3. #include "Nodo.h"
  4.  
  5. class Lista {
  6. public:
  7.     Lista();
  8.     Lista(const Lista& orig);
  9.     virtual ~Lista();
  10.     void setHead(int d);
  11.     Nodo* getHead();
  12.     bool isEmpty();
  13. private:
  14.     Nodo *head;
  15. };
  16.  
  17. #endif	/* LISTA_H */
  18.  
  19.  

Código
  1. #include "Lista.h"
  2. #include "Nodo.h"
  3. #include <iostream>
  4.  
  5. using namespace std;
  6.  
  7. Lista::Lista() {
  8.  
  9.     head = NULL;
  10.  
  11. }
  12.  
  13. Lista::Lista(const Lista& orig) {   
  14. }
  15.  
  16. /*
  17.  * Destructor de la lista. Borra uno por uno todos los Nodos que se asigno de for
  18.  * ma dinamica.
  19.  * 
  20.  */
  21.  
  22. Lista::~Lista() {
  23.  
  24.     cout <<"\nBorrando lista, borrando todos los elementos...\n";
  25.  
  26.     Nodo *aux;
  27.  
  28.     while(head != NULL){
  29.  
  30.         aux = head->getSiguiente(); //Guardando la posicion del nodo siguiente
  31.         delete head; //Borrando lo que hay en la posicion de head
  32.         head = aux; //Head apunta al siguiente del Head anterior
  33.  
  34.     }
  35.  
  36. }
  37.  
  38. /*
  39.  * Funcion que agrega un nuvo Nodo en la lista, colocandolo en la cabeza.
  40.  */
  41.  
  42. void Lista::setHead(int d){
  43.  
  44.     Nodo *nuevo = new Nodo(d);
  45.  
  46.     if(isEmpty()){
  47.  
  48.         head = nuevo;
  49.  
  50.     }else{
  51.  
  52.         nuevo->setSiguiente(head);
  53.         head = nuevo;
  54.  
  55.     }
  56.  
  57. }
  58.  
  59. /*
  60.  * Funcion que obtiene el primer Nodo de la lista.
  61.  */
  62.  
  63. Nodo* Lista::getHead(){
  64.  
  65.     if(isEmpty()){
  66.  
  67.         cout << "\nLa pila esta vacia\n";
  68.  
  69.     }else{
  70.  
  71.         return head;
  72.  
  73.     }
  74.  
  75. }
  76.  
  77. /*
  78.  * Funcion que determina si la lista esta vacia o no lo esta.
  79.  */
  80.  
  81. bool Lista::isEmpty(){
  82.  
  83.     if(head == NULL){
  84.  
  85.         return true;
  86.  
  87.     }else{
  88.  
  89.         return false;
  90.  
  91.     }
  92.  
  93. }

Código
  1. #ifndef NODO_H
  2. #define	NODO_H
  3.  
  4. class Nodo {
  5. public:
  6.     Nodo(int d);
  7.     Nodo(const Nodo& orig);
  8.     virtual ~Nodo();
  9.     void setSiguiente(Nodo *s);
  10.     int getDato();
  11.     Nodo* getSiguiente();
  12. private:
  13.     int dato;
  14.     Nodo *siguiente;
  15. };
  16.  
  17. #endif	/* NODO_H */
  18.  
  19.  

Código
  1. #include "Nodo.h"
  2. #include <iostream>
  3.  
  4. using namespace std;
  5.  
  6. Nodo::Nodo(int d) {
  7.  
  8.     dato = d;
  9.     siguiente = NULL;
  10. }
  11.  
  12. Nodo::Nodo(const Nodo& orig) {
  13. }
  14.  
  15. Nodo::~Nodo() {
  16.  
  17.     cout <<"\nDestruyendo nodo...\n";
  18.  
  19. }
  20.  
  21. /*
  22.  * Funcion que agregar el nodo siguiente
  23.  */
  24.  
  25. void Nodo::setSiguiente(Nodo *s){
  26.  
  27.     siguiente = s;
  28.  
  29. }
  30.  
  31. /*
  32.  * Funcion que obtiene el valor contenido del nodo.
  33.  */
  34.  
  35. int Nodo::getDato(){
  36.  
  37.     return dato;
  38.  
  39. }
  40.  
  41. /*
  42.  * Metodo que obtiene un puntero al siguiente Nodo.
  43.  */
  44.  
  45. Nodo* Nodo::getSiguiente(){
  46.  
  47.     return siguiente;
  48.  
  49. }
  50.  
  51.  

Código
  1. #include <cstdlib>
  2. #include <iostream>
  3. #include "Lista.h"
  4. #include "Nodo.h"
  5.  
  6. using namespace std;
  7.  
  8. int main(int argc, char** argv) {
  9.  
  10.     Lista lista;
  11.  
  12.     lista.setHead(10);
  13.     lista.setHead(9);
  14.     lista.setHead(8);
  15.     lista.setHead(7);
  16.     lista.setHead(6);
  17.     lista.setHead(5);
  18.     lista.setHead(4);
  19.     lista.setHead(3);
  20.     lista.setHead(2);
  21.     lista.setHead(1);
  22.     lista.setHead(0);
  23.  
  24.     //Obteniendo el primer nodo de la lista.
  25.  
  26.     Nodo *cabeza = lista.getHead();
  27.  
  28.     //Imprimiendo por pantalla los valores contenidos en cada nodo.
  29.  
  30.     while(cabeza != NULL){
  31.  
  32.         cout << cabeza->getDato() << endl;
  33.         cabeza = cabeza->getSiguiente();
  34.  
  35.     }
  36.  
  37.     return 0;
  38. }
  39.  
  40.  

Título: Re: Lista enlazada, eliminando todos los nodos en C++ (¿ Estara bien ?)
Publicado por: eferion en 29 Septiembre 2013, 00:01 am
No veo problemas en tu forma de destruir la lista.

En cualquier caso, si quieres verificar que se libera toda la memoria haz la prueba de crear X nodos y después destruir la lista... si en la consola aparecen X nodos destruidos entonces no queda memoria sin liberar.

Además, si rebuscas un poco con google hay librerías que te ayudan a evitar lagunas de memoria... básicamente te avisan cuando se te ha olvidado algún delete.


Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines