Se agrega un test de la DLList.

[z.facultad/75.42/euler-oo.git] / dllist.cpp

diff --git a/dllist.cpp b/dllist.cpp
index a2994fd467a6f8a75e7f0132bc3d4c883ee92d85..b2c2693f29e7d3a00eb835ce3ade278c2de3710b 100644 (file)
--- a/dllist.cpp
+++ b/dllist.cpp
@@ -1,9 +1,9 @@
-/* vim: set et sts=4 sw=4 fdm=indent fdl=1 fdn=0 fo+=t tw=80:
+/* vim: set et sts=4 sw=4 fdm=indent fdn=1 fo+=t tw=80:

  *
  * Taller de Programación (75.42).
  *
  *
  * Taller de Programación (75.42).
  *

- * Ejercicio Número 2:
- * Programa calculadora.
+ * Ejercicio Número 3:
+ * Lista de figuras.

  *
  * Copyleft 2003 - Leandro Lucarella <llucare@fi.uba.ar>
  * Puede copiar, modificar y distribuir este programa bajo los términos de
  *
  * Copyleft 2003 - Leandro Lucarella <llucare@fi.uba.ar>
  * Puede copiar, modificar y distribuir este programa bajo los términos de


@@ -14,51 +14,61 @@
  * $Id$
  */
 
  * $Id$
  */
 

-// TODO metodos que devuelven NULL si la lista esta vacia.
-//      poner comentarios en línea simple?

 #include "dllist.h"
 #include "dllist.h"

+#include <cstdlib>

 
 

-DLList::DLList(void): first(NULL), current(NULL), last(NULL) {}
+#ifdef DEBUG
+#   include <iostream>
+#endif
+
+DLList::DLList(void): first(NULL), curr(NULL), last(NULL) {
+#ifdef DEBUG
+    std::cerr << "En constructor de DLList." << std::endl;
+#endif
+}

 
 DLList::~DLList(void) {
 
 DLList::~DLList(void) {

+#ifdef DEBUG
+    std::cerr << "En destructor de DLList." << std::endl;
+#endif

     /* Elimino los nodos. */
     /* Elimino los nodos. */

-    while (!DLList_empty(list)) {
-        DLList_pop(list);
+    while (!empty()) {
+        pop();

     }
 }
 
 bool DLList::empty(void) {
     }
 }
 
 bool DLList::empty(void) {

-    return this->first == NULL;
+    return first == NULL;

 }
 
 void* DLList::begin(void) {
 }
 
 void* DLList::begin(void) {

-    this->current = this->first;
+    curr = first;

     /* Si hay un nodo, devulevo sus datos, si no NULL. */
     /* Si hay un nodo, devulevo sus datos, si no NULL. */

-    return this->current ? this->current->data : NULL;
+    return curr ? curr->data : NULL;

 }
 
 void* DLList::end(void) {
 }
 
 void* DLList::end(void) {

-    this->current = this->last;
+    curr = last;

     /* Si hay un nodo, devulevo sus datos, si no NULL. */
     /* Si hay un nodo, devulevo sus datos, si no NULL. */

-    return this->current ? this->current->data : NULL;
+    return curr ? curr->data : NULL;

 }
 
 bool DLList::have_more(void) {
 }
 
 bool DLList::have_more(void) {

-    return this->current != NULL;
+    return curr != NULL;

 }
 
 void* DLList::current(void) {
 }
 
 void* DLList::current(void) {

-    return this->current ? this->current->data : NULL;
+    return curr ? curr->data : NULL;

 }
 
 void* DLList::next(void) {
 }
 
 void* DLList::next(void) {

-    DLListNode* cur = this->current;
+    DLListNode* new_curr = curr;

     /* Si no está vacía ni ya fue terminada de recorrer. */
     /* Si no está vacía ni ya fue terminada de recorrer. */

-    if (cur) {
+    if (new_curr) {

         /* Apuntamos el actual al próximo. */
         /* Apuntamos el actual al próximo. */

-        this->current = cur->next;
+        curr = new_curr->next;

         /* Devolvemos los datos del próximo o NULL si no había otro. */
         /* Devolvemos los datos del próximo o NULL si no había otro. */

-        return this->current ? this->current->data : NULL;
+        return curr ? curr->data : NULL;

     /* Si está vacía o ya fue terminada de recorrer devolvemos NULL. */
     } else {
         return NULL;
     /* Si está vacía o ya fue terminada de recorrer devolvemos NULL. */
     } else {
         return NULL;


@@ -66,13 +76,13 @@ void* DLList::next(void) {
 }
 
 void* DLList::prev(void) {
 }
 
 void* DLList::prev(void) {

-    DLListNode* cur = this->current;
+    DLListNode* new_curr = curr;

     /* Si no está vacía ni ya fue terminada de recorrer. */
     /* Si no está vacía ni ya fue terminada de recorrer. */

-    if (cur) {
+    if (new_curr) {

         /* Apuntamos el actual al anterior. */
         /* Apuntamos el actual al anterior. */

-        this->current = cur->prev;
+        curr = new_curr->prev;

         /* Devolvemos los datos del anterior o NULL si no había otro. */
         /* Devolvemos los datos del anterior o NULL si no había otro. */

-        return this->current ? this->current->data : NULL;
+        return curr ? curr->data : NULL;

     /* Si está vacía o ya fue terminada de recorrer devolvemos NULL. */
     } else {
         return NULL;
     /* Si está vacía o ya fue terminada de recorrer devolvemos NULL. */
     } else {
         return NULL;


@@ -80,21 +90,21 @@ void* DLList::prev(void) {
 }
 
 bool DLList::unshift(void* data) {
 }
 
 bool DLList::unshift(void* data) {

-    DLListNode* node = new DLListNode(NULL, data, this->first);
+    DLListNode* node = new DLListNode(NULL, data, first);

     /* Si obtenemos la memoria bien, actualizamos lo que sea necesario. */
     if (node) {
         /* Apunto el nodo actual al nuevo nodo. */
     /* Si obtenemos la memoria bien, actualizamos lo que sea necesario. */
     if (node) {
         /* Apunto el nodo actual al nuevo nodo. */

-        this->current = node;
+        curr = node;

         /* Si la lista está vacía hay que hacer apuntar todo al nuevo nodo. */
         /* Si la lista está vacía hay que hacer apuntar todo al nuevo nodo. */

-        if (this->first == NULL) {
-            this->first = node;
-            this->last  = node;
+        if (first == NULL) {
+            first = node;
+            last  = node;

         /* Si no está vacía. */
         } else {
             /* Apunto el nodo anterior al primer nodo de la lista al nuevo. */
         /* Si no está vacía. */
         } else {
             /* Apunto el nodo anterior al primer nodo de la lista al nuevo. */

-            this->first->prev = node;
+            first->prev = node;

             /* Apunto el primer nodo de la lista al nuevo. */
             /* Apunto el primer nodo de la lista al nuevo. */

-            this->first = node;
+            first = node;

         }
         return true;
     } else {
         }
         return true;
     } else {


@@ -103,21 +113,21 @@ bool DLList::unshift(void* data) {
 }
 
 bool DLList::push(void* data) {
 }
 
 bool DLList::push(void* data) {

-    DLListNode* node = new DLListNode(this->last, data, NULL);
+    DLListNode* node = new DLListNode(last, data, NULL);

     /* Si obtenemos la memoria bien, actualizamos lo que sea necesario. */
     if (node) {
         /* Apunto el nodo actual al nuevo nodo. */
     /* Si obtenemos la memoria bien, actualizamos lo que sea necesario. */
     if (node) {
         /* Apunto el nodo actual al nuevo nodo. */

-        this->current = node;
+        curr = node;

         /* Si la lista está vacía hay que hacer apuntar todo al nuevo nodo. */
         /* Si la lista está vacía hay que hacer apuntar todo al nuevo nodo. */

-        if (this->first == NULL) {
-            this->first = node;
-            this->last  = node;
+        if (first == NULL) {
+            first = node;
+            last  = node;

         /* Si no está vacía. */
         } else {
             /* Apunto el próximo nodo del último nodo de la lista al nuevo. */
         /* Si no está vacía. */
         } else {
             /* Apunto el próximo nodo del último nodo de la lista al nuevo. */

-            this->last->next = node;
+            last->next = node;

             /* Apunto el último nodo de la lista al nuevo. */
             /* Apunto el último nodo de la lista al nuevo. */

-            this->last = node;
+            last = node;

         }
         return true;
     } else {
         }
         return true;
     } else {


@@ -126,72 +136,87 @@ bool DLList::push(void* data) {
 }
 
 void* DLList::shift(void) {
 }
 
 void* DLList::shift(void) {

+    // Si está vacía devuelve NULL.
+    if (first == NULL)  {
+        return NULL;
+    }

     /* Primer nodo */
     /* Primer nodo */

-    DLListNode* node = this->first;
+    DLListNode* node = first;

     /* Datos del primer nodo. */
     void* data = node->data;
     /* Pongo como primer nodo al siguiente. */
     /* Datos del primer nodo. */
     void* data = node->data;
     /* Pongo como primer nodo al siguiente. */

-    this->first = node->next;
+    first = node->next;

     /* Pongo al primero como nodo actual. */
     /* Pongo al primero como nodo actual. */

-    this->current = this->first;
+    curr = first;

     /* Si era el único pongo el último en NULL. */
     /* Si era el único pongo el último en NULL. */

-    if (!this->first) {
-        this->last = NULL;
+    if (!first) {
+        last = NULL;

     /* Si no, pongo el anterior en NULL. */
     } else {
     /* Si no, pongo el anterior en NULL. */
     } else {

-        this->first->prev = NULL;
+        first->prev = NULL;

     }
     /* Libero memoria del nodo. */
     delete node;
     }
     /* Libero memoria del nodo. */
     delete node;

+    // Devuelvo elemento.

     return data;
 }
 
 void* DLList::pop(void) {
     return data;
 }
 
 void* DLList::pop(void) {

+    // Si está vacía devuelve NULL.
+    if (first == NULL)  {
+        return NULL;
+    }

     /* Último nodo */
     /* Último nodo */

-    DLListNode* node = this->last;
+    DLListNode* node = last;

     /* Datos del último nodo. */
     void* data = node->data;
     /* Pongo como último nodo al anterior. */
     /* Datos del último nodo. */
     void* data = node->data;
     /* Pongo como último nodo al anterior. */

-    this->last = node->prev;
+    last = node->prev;

     /* Pongo al último como nodo actual. */
     /* Pongo al último como nodo actual. */

-    this->current = this->last;
+    curr = last;

     /* Si era el único pongo el primero en NULL. */
     /* Si era el único pongo el primero en NULL. */

-    if (!this->last) {
-        this->first = NULL;
+    if (!last) {
+        first = NULL;

     /* Si no, pongo el siguiente en NULL. */
     } else {
     /* Si no, pongo el siguiente en NULL. */
     } else {

-        this->last->next = NULL;
+        last->next = NULL;

     }
     /* Libero memoria del nodo. */
     delete node;
     }
     /* Libero memoria del nodo. */
     delete node;

+    // Devuelvo elemento.

     return data;
 }
 
 void* DLList::remove_current(void) {
     return data;
 }
 
 void* DLList::remove_current(void) {

+    // Si no hay un nodo seleccionado devuelve NULL.
+    if (curr == NULL)  {
+        return NULL;
+    }

     /* Nodo actual */
     /* Nodo actual */

-    DLListNode* current = this->current;
+    DLListNode* new_curr = curr;

     /* Datos del nodo actual. */
     /* Datos del nodo actual. */

-    void* data = current->data;
+    void* data = new_curr->data;

     /* Si tiene siguiente. */
     /* Si tiene siguiente. */

-    if (current->next) {
+    if (new_curr->next) {

         /* Se pone como anterior del siguiente al anterior del actual. */
         /* Se pone como anterior del siguiente al anterior del actual. */

-        current->next->prev = current->prev;
+        new_curr->next->prev = new_curr->prev;

     /* Si no tiene siguiente, se pone como último al anterior del actual. */
     } else {
     /* Si no tiene siguiente, se pone como último al anterior del actual. */
     } else {

-        this->last = current->prev;
+        last = new_curr->prev;

     }
     /* Si tiene anterior. */
     }
     /* Si tiene anterior. */

-    if (current->prev) {
+    if (new_curr->prev) {

         /* Se pone como siguiente del anterior al siguiente del actual. */
         /* Se pone como siguiente del anterior al siguiente del actual. */

-        current->prev->next = current->next;
+        new_curr->prev->next = new_curr->next;

     /* Si no tiene anterior, se pone como primero al siguiente del actual. */
     } else {
     /* Si no tiene anterior, se pone como primero al siguiente del actual. */
     } else {

-        this->first = current->next;
+        first = new_curr->next;

     }
     /* Pongo como elemento actual al próximo elemento. */
     }
     /* Pongo como elemento actual al próximo elemento. */

-    this->current = current->next;
+    curr = new_curr->next;

     /* Libero memoria del nodo. */
     /* Libero memoria del nodo. */

-    delete current;
+    delete new_curr;
+    // Devuelvo elemento.

     return data;
 }
 
     return data;
 }