X-Git-Url: https://git.llucax.com/z.facultad/75.42/euler-oo.git/blobdiff_plain/a518bb449e4be4267cdcd90dc0dd118bf6cdd0e0..79b3017669076520a37e1250b7a55bd7972701f3:/dllist.cpp?ds=sidebyside

diff --git a/dllist.cpp b/dllist.cpp
index 9ef4f52..b2c2693 100644
--- a/dllist.cpp
+++ b/dllist.cpp
@@ -21,7 +21,7 @@
 #   include <iostream>
 #endif
 
-DLList::DLList(void): _first(NULL), _current(NULL), _last(NULL) {
+DLList::DLList(void): first(NULL), curr(NULL), last(NULL) {
 #ifdef DEBUG
     std::cerr << "En constructor de DLList." << std::endl;
 #endif
@@ -38,37 +38,37 @@ DLList::~DLList(void) {
 }
 
 bool DLList::empty(void) {
-    return _first == NULL;
+    return first == NULL;
 }
 
 void* DLList::begin(void) {
-    _current = _first;
+    curr = first;
     /* Si hay un nodo, devulevo sus datos, si no NULL. */
-    return _current ? _current->data : NULL;
+    return curr ? curr->data : NULL;
 }
 
 void* DLList::end(void) {
-    _current = _last;
+    curr = last;
     /* Si hay un nodo, devulevo sus datos, si no NULL. */
-    return _current ? _current->data : NULL;
+    return curr ? curr->data : NULL;
 }
 
 bool DLList::have_more(void) {
-    return _current != NULL;
+    return curr != NULL;
 }
 
 void* DLList::current(void) {
-    return _current ? _current->data : NULL;
+    return curr ? curr->data : NULL;
 }
 
 void* DLList::next(void) {
-    DLListNode* current = _current;
+    DLListNode* new_curr = curr;
     /* Si no está vacía ni ya fue terminada de recorrer. */
-    if (current) {
+    if (new_curr) {
         /* Apuntamos el actual al próximo. */
-        _current = current->next;
+        curr = new_curr->next;
         /* Devolvemos los datos del próximo o NULL si no había otro. */
-        return _current ? _current->data : NULL;
+        return curr ? curr->data : NULL;
     /* Si está vacía o ya fue terminada de recorrer devolvemos NULL. */
     } else {
         return NULL;
@@ -76,13 +76,13 @@ void* DLList::next(void) {
 }
 
 void* DLList::prev(void) {
-    DLListNode* current = _current;
+    DLListNode* new_curr = curr;
     /* Si no está vacía ni ya fue terminada de recorrer. */
-    if (current) {
+    if (new_curr) {
         /* Apuntamos el actual al anterior. */
-        _current = current->prev;
+        curr = new_curr->prev;
         /* Devolvemos los datos del anterior o NULL si no había otro. */
-        return _current ? _current->data : NULL;
+        return curr ? curr->data : NULL;
     /* Si está vacía o ya fue terminada de recorrer devolvemos NULL. */
     } else {
         return NULL;
@@ -90,21 +90,21 @@ void* DLList::prev(void) {
 }
 
 bool DLList::unshift(void* data) {
-    DLListNode* node = new DLListNode(NULL, data, _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. */
-        _current = node;
+        curr = node;
         /* Si la lista está vacía hay que hacer apuntar todo al nuevo nodo. */
-        if (_first == NULL) {
-            _first = node;
-            _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. */
-            _first->prev = node;
+            first->prev = node;
             /* Apunto el primer nodo de la lista al nuevo. */
-            _first = node;
+            first = node;
         }
         return true;
     } else {
@@ -113,21 +113,21 @@ bool DLList::unshift(void* data) {
 }
 
 bool DLList::push(void* data) {
-    DLListNode* node = new DLListNode(_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. */
-        _current = node;
+        curr = node;
         /* Si la lista está vacía hay que hacer apuntar todo al nuevo nodo. */
-        if (_first == NULL) {
-            _first = node;
-            _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. */
-            _last->next = node;
+            last->next = node;
             /* Apunto el último nodo de la lista al nuevo. */
-            _last = node;
+            last = node;
         }
         return true;
     } else {
@@ -137,83 +137,86 @@ bool DLList::push(void* data) {
 
 void* DLList::shift(void) {
     // Si está vacía devuelve NULL.
-    if (_first == NULL)  {
+    if (first == NULL)  {
         return NULL;
     }
     /* Primer nodo */
-    DLListNode* node = _first;
+    DLListNode* node = first;
     /* Datos del primer nodo. */
     void* data = node->data;
     /* Pongo como primer nodo al siguiente. */
-    _first = node->next;
+    first = node->next;
     /* Pongo al primero como nodo actual. */
-    _current = _first;
+    curr = first;
     /* Si era el único pongo el último en NULL. */
-    if (!_first) {
-        _last = NULL;
+    if (!first) {
+        last = NULL;
     /* Si no, pongo el anterior en NULL. */
     } else {
-        _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)  {
+    if (first == NULL)  {
         return NULL;
     }
     /* Último nodo */
-    DLListNode* node = _last;
+    DLListNode* node = last;
     /* Datos del último nodo. */
     void* data = node->data;
     /* Pongo como último nodo al anterior. */
-    _last = node->prev;
+    last = node->prev;
     /* Pongo al último como nodo actual. */
-    _current = _last;
+    curr = last;
     /* Si era el único pongo el primero en NULL. */
-    if (!_last) {
-        _first = NULL;
+    if (!last) {
+        first = NULL;
     /* Si no, pongo el siguiente en NULL. */
     } else {
-        _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 (_current == NULL)  {
+    if (curr == NULL)  {
         return NULL;
     }
     /* Nodo actual */
-    DLListNode* current = _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 {
-        _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 {
-        _first = current->next;
+        first = new_curr->next;
     }
     /* Pongo como elemento actual al próximo elemento. */
-    _current = current->next;
+    curr = new_curr->next;
     /* Libero memoria del nodo. */
-    delete current;
+    delete new_curr;
+    // Devuelvo elemento.
     return data;
 }