-/* 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).
*
- * 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
* $Id$
*/
-// TODO metodos que devuelven NULL si la lista esta vacia.
-// poner comentarios en línea simple?
#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) {
+#ifdef DEBUG
+ std::cerr << "En destructor de DLList." << std::endl;
+#endif
/* 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;
+ curr = first;
/* 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) {
- this->current = this->last;
+ curr = last;
/* 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) {
- return this->current != NULL;
+ return curr != NULL;
}
void* DLList::current(void) {
- return this->current ? this->current->data : NULL;
+ return curr ? curr->data : NULL;
}
void* DLList::next(void) {
- DLListNode* cur = this->current;
+ DLListNode* new_curr = curr;
/* Si no está vacía ni ya fue terminada de recorrer. */
- if (cur) {
+ if (new_curr) {
/* 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. */
- 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;
}
void* DLList::prev(void) {
- DLListNode* cur = this->current;
+ DLListNode* new_curr = curr;
/* Si no está vacía ni ya fue terminada de recorrer. */
- if (cur) {
+ if (new_curr) {
/* 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. */
- 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;
}
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;
+ curr = 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 {
}
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;
+ curr = 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 {
}
void* DLList::shift(void) {
+ // Si está vacía devuelve 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;
+ curr = 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;
+ // Devuelvo elemento.
return data;
}
void* DLList::pop(void) {
+ // Si está vacía devuelve 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;
+ curr = 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;
+ // Devuelvo elemento.
return data;
}
void* DLList::remove_current(void) {
+ // Si no hay un nodo seleccionado devuelve NULL.
+ if (curr == NULL) {
+ return NULL;
+ }
/* Nodo actual */
- DLListNode* current = this->current;
+ DLListNode* new_curr = curr;
/* Datos del nodo actual. */
- void* data = current->data;
+ void* data = new_curr->data;
/* Si tiene siguiente. */
- if (current->next) {
+ if (new_curr->next) {
/* 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 {
- this->last = current->prev;
+ last = new_curr->prev;
}
/* Si tiene anterior. */
- if (current->prev) {
+ if (new_curr->prev) {
/* 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 {
- this->first = current->next;
+ first = new_curr->next;
}
/* Pongo como elemento actual al próximo elemento. */
- this->current = current->next;
+ curr = new_curr->next;
/* Libero memoria del nodo. */
- delete current;
+ delete new_curr;
+ // Devuelvo elemento.
return data;
}
projects / z.facultad / 75.42 / euler-oo.git / blobdiff