La DLList ya compila.

diff --git a/Makefile b/Makefile
new file mode 100644 (file)
index 0000000..5800906
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,51 @@
+#
+# Taller de Programación (75.42).
+#
+# Trabajo Práctico 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
+# la licencia GPL (http://www.gnu.org/).
+#
+# Creado: vie sep 19 00:38:51 ART 2003
+#
+# $Id$
+#
+
+# Opciones para el compilador.
+CXXFLAGS=-ansi -pedantic -Wall -g3 -DDEBUG
+#CC=gcc-3.2
+
+# Pruebas.
+TESTS=
+
+# Programa a compilar.
+TARGETS=$(TESTS) tp3
+
+# Regla por defecto.
+all: $(TARGETS)
+
+# Pruebas.
+tests: $(TESTS)
+
+dllist_test: dllist.o
+
+memdebug_test: dllist.o meminfo.o memdebug.o
+
+parser_equation_test: dllist.o strutil.o meminfo.o memdebug.o parseerror.o
+
+# Regla para borrar.
+clean:
+       @echo "Limpiando..."
+       @rm -fR $(TARGETS) *.o core tp2 corrida_*.txt html latex* *.ps *.pdf
+
+# Preety-printing del código fuente.
+code.ps: 
+       enscript -j -E -U2 -C --fancy-header=squeeze --color -pcode.ps
+
+# Informe.
+informe: code.ps
+       @doxygen
+       @cd latex && make refman.pdf && cd ..
+       @doxygen Doxyfile.imprimible

diff --git a/dllist.cpp b/dllist.cpp
index e34e78782bcb9f839cba9e8b80329db5ac3fef2d..605c159991696e6b1308d0ad4a8726956e809b62 100644 (file)
--- a/dllist.cpp
+++ b/dllist.cpp
@@ -2,8 +2,8 @@
  *
  * 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
@@ -15,48 +15,49 @@
  */
 
 #include "dllist.h"
+#include <cstdlib>
 
-DLList::DLList(void): first(NULL), current(NULL), last(NULL) {}
+DLList::DLList(void): _first(NULL), _current(NULL), _last(NULL) {}
 
 DLList::~DLList(void) {
     /* Elimino los nodos. */
-    while (!DLList_empty(list)) {
-        DLList_pop(list);
+    while (!empty()) {
+        pop();
     }
 }
 
 bool DLList::empty(void) {
-    return this->first == NULL;
+    return _first == NULL;
 }
 
 void* DLList::begin(void) {
-    this->current = this->first;
+    _current = _first;
     /* Si hay un nodo, devulevo sus datos, si no NULL. */
-    return this->current ? this->current->data : NULL;
+    return _current ? _current->data : NULL;
 }
 
 void* DLList::end(void) {
-    this->current = this->last;
+    _current = _last;
     /* Si hay un nodo, devulevo sus datos, si no NULL. */
-    return this->current ? this->current->data : NULL;
+    return _current ? _current->data : NULL;
 }
 
 bool DLList::have_more(void) {
-    return this->current != NULL;
+    return _current != NULL;
 }
 
 void* DLList::current(void) {
-    return this->current ? this->current->data : NULL;
+    return _current ? _current->data : NULL;
 }
 
 void* DLList::next(void) {
-    DLListNode* cur = this->current;
+    DLListNode* current = _current;
     /* Si no está vacía ni ya fue terminada de recorrer. */
-    if (cur) {
+    if (current) {
         /* Apuntamos el actual al próximo. */
-        this->current = cur->next;
+        _current = current->next;
         /* Devolvemos los datos del próximo o NULL si no había otro. */
-        return this->current ? this->current->data : NULL;
+        return _current ? _current->data : NULL;
     /* Si está vacía o ya fue terminada de recorrer devolvemos NULL. */
     } else {
         return NULL;
@@ -64,13 +65,13 @@ void* DLList::next(void) {
 }
 
 void* DLList::prev(void) {
-    DLListNode* cur = this->current;
+    DLListNode* current = _current;
     /* Si no está vacía ni ya fue terminada de recorrer. */
-    if (cur) {
+    if (current) {
         /* Apuntamos el actual al anterior. */
-        this->current = cur->prev;
+        _current = current->prev;
         /* Devolvemos los datos del anterior o NULL si no había otro. */
-        return this->current ? this->current->data : NULL;
+        return _current ? _current->data : NULL;
     /* Si está vacía o ya fue terminada de recorrer devolvemos NULL. */
     } else {
         return NULL;
@@ -78,21 +79,21 @@ void* DLList::prev(void) {
 }
 
 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. */
-        this->current = node;
+        _current = node;
         /* 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. */
-            this->first->prev = node;
+            _first->prev = node;
             /* Apunto el primer nodo de la lista al nuevo. */
-            this->first = node;
+            _first = node;
         }
         return true;
     } else {
@@ -101,21 +102,21 @@ bool DLList::unshift(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. */
-        this->current = node;
+        _current = node;
         /* 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. */
-            this->last->next = node;
+            _last->next = node;
             /* Apunto el último nodo de la lista al nuevo. */
-            this->last = node;
+            _last = node;
         }
         return true;
     } else {
@@ -125,23 +126,23 @@ bool DLList::push(void* data) {
 
 void* DLList::shift(void) {
     // Si está vacía devuelve NULL.
-    if (this->first == NULL)  {
+    if (_first == NULL)  {
         return NULL;
     }
     /* Primer nodo */
-    DLListNode* node = this->first;
+    DLListNode* node = _first;
     /* 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. */
-    this->current = this->first;
+    _current = _first;
     /* 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 {
-        this->first->prev = NULL;
+        _first->prev = NULL;
     }
     /* Libero memoria del nodo. */
     delete node;
@@ -150,23 +151,23 @@ void* DLList::shift(void) {
 
 void* DLList::pop(void) {
     // Si está vacía devuelve NULL.
-    if (this->first == NULL)  {
+    if (_first == NULL)  {
         return NULL;
     }
     /* Último nodo */
-    DLListNode* node = this->last;
+    DLListNode* node = _last;
     /* 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. */
-    this->current = this->last;
+    _current = _last;
     /* 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 {
-        this->last->next = NULL;
+        _last->next = NULL;
     }
     /* Libero memoria del nodo. */
     delete node;
@@ -175,11 +176,11 @@ void* DLList::pop(void) {
 
 void* DLList::remove_current(void) {
     // Si no hay un nodo seleccionado devuelve NULL.
-    if (this->current == NULL)  {
+    if (_current == NULL)  {
         return NULL;
     }
     /* Nodo actual */
-    DLListNode* current = this->current;
+    DLListNode* current = _current;
     /* Datos del nodo actual. */
     void* data = current->data;
     /* Si tiene siguiente. */
@@ -188,7 +189,7 @@ void* DLList::remove_current(void) {
         current->next->prev = current->prev;
     /* Si no tiene siguiente, se pone como último al anterior del actual. */
     } else {
-        this->last = current->prev;
+        _last = current->prev;
     }
     /* Si tiene anterior. */
     if (current->prev) {
@@ -196,10 +197,10 @@ void* DLList::remove_current(void) {
         current->prev->next = current->next;
     /* Si no tiene anterior, se pone como primero al siguiente del actual. */
     } else {
-        this->first = current->next;
+        _first = current->next;
     }
     /* Pongo como elemento actual al próximo elemento. */
-    this->current = current->next;
+    _current = current->next;
     /* Libero memoria del nodo. */
     delete current;
     return data;

diff --git a/dllist.h b/dllist.h
index 94c7d54c1d96213ddd7430e772e730539a357009..162ce255adca79b6ff1377c3cc49a7b5257dcffa 100644 (file)
--- a/dllist.h
+++ b/dllist.h
@@ -3,7 +3,7 @@
  * Taller de Programación (75.42).
  *
  * Ejercicio Número 3:
- * TODO
+ * Lista de figuras.
  *
  * Copyleft 2003 - Leandro Lucarella <llucare@fi.uba.ar>
  * Puede copiar, modificar y distribuir este programa bajo los términos de
@@ -17,39 +17,47 @@
 #ifndef DLLIST_H
 #define DLLIST_H
 
-/** Nodo de la lista doblemente enlazada. */
+#include <cstdlib>
+
+/// Nodo de la lista doblemente enlazada.
 struct DLListNode {
-    /** Puntero al nodo anterior. */
+
+    /// Puntero al nodo anterior.
     DLListNode* prev;
-    /** Datos almacenados en el nodo. */
+
+    /// Datos almacenados en el nodo.
     void* data;
-    /** Puntero al próximo nodo. */
+
+    /// Puntero al próximo nodo.
     DLListNode* next;
+
+    /// Constructor.
+    DLListNode(DLListNode* prev = NULL, void* data = NULL,
+            DLListNode* next = NULL): prev(prev), data(data), next(next) {}
+
 };
 
-/**
- * Lista doblemente enlazada.
- */
+/// Lista doblemente enlazada.
 class DLList {
 
     protected:
-        /** Puntero al primer nodo. */
-        DLListNode* first;
-        /** Puntero al nodo actual. */
-        DLListNode* current;
-        /** Puntero al último nodo. */
-        DLListNode* last;
+
+        /// Puntero al primer nodo.
+        DLListNode* _first;
+
+        /// Puntero al nodo actual.
+        DLListNode* _current;
+
+        /// Puntero al último nodo.
+        DLListNode* _last;
 
     public:
-        /**
-         * Crea una nueva lista.
-         */
+
+        /// Crea una nueva lista.
         DLList(void);
 
-        /**
-         * Libera la memoria ocupada por una lista.
-         */
-        ~DLList(void);
+        /// Libera la memoria ocupada por una lista.
+        virtual ~DLList(void);
 
         /**
          * Indica si está vacía.
@@ -204,4 +212,6 @@ class DLList {
          */
         void* remove_current(void);
 
+};
+
 #endif /* DLLIST_H */