Incremento aplicación operador/iterador

Question

estoy tratando de averiguar un par de cosas aquí:

1. ¿Cómo se escribe un operador de incremento para una clase de nodo que tiene un puntero al siguiente nodo?

2. ¿Cómo implemento iteradores para una clase como la siguiente?

   #include <iostream> 
   #include <vector> 
   using namespace std; 
   
   template <typename T> 
   class Node { 
   public: 
       Node(int i=0):val(i) {} 
       Node*& operator++(int i=0) {return next;}; 
   
       T val; 
       Node *next; 
   }; 
   
   //================================================ 
   int main() { 
   
       Node<int> *head, *tmp1, *tmp2; 
   
       tmp1 = new Node<int>(0); 
       head = tmp1; 
   
       for (int i=1; i<10; ++i) { 
   
        tmp2 = new Node<int>(i); 
        tmp1->next = tmp2; 
        tmp1 = tmp2; 
       } 
   
       while (head != NULL) { 
   
        cout << head->val << " '"; 
        head = head->operator++(0); //How do I make it work with ++head;? 
       } 
   } 
   

Esto no es un buen ejemplo para la demostración de la sobrecarga de operadores o iteradores.

Answer 1

No implementa operator++ para la clase Node; lo implementa para el iterador. La clase de iterador debe ser una clase separada.

Y por favor, no estropear su plantilla al hacer suposiciones (ya que es un valT, el constructor debe aceptar un T, no un int). Además, no ignore el parámetro int para el operador ++ así: es un maniquí utilizado para distinguir la implementación de preincremento de la implementación posterior al incremento.

template <typename T> 
struct Node { 
    T val; 
    Node *next; 

    Node(const T& t = T()) : val(t) {} 
}; 

template <typename T> 
struct node_iter { 
    Node<T>* current; 
    node_iter(Node<T>* current): current(current) {} 

    const node_iter& operator++() { current = current->next; return *this; } 
    node_iter operator++(int) { 
     node_iter result = *this; ++(*this); return result; 
    } 
    T& operator*() { return current->val; } 
}; 

int main() { 
    // We make an array of nodes, and link them together - no point in 
    // dynamic allocation for such a simple example. 
    Node<int> nodes[10]; 
    for (int i = 0; i < 10; ++i) { 
     nodes[i] = Node<int>(i); 
     nodes[i].next = (i == 9) ? nodes + i + 1 : 0; 
    } 

    // we supply a pointer to the first element of the array 
    node_iter<int> test(nodes); 
    // and then iterate: 
    while (test.current) { 
     cout << *test++ << " "; 
    } 
    // Exercise: try linking the nodes in reverse order. Therefore, we create 
    // 'test' with a pointer to the last element of the array, rather than 
    // the first. However, we will not need to change the while loop, because 
    // of how the operator overload works. 

    // Exercise: try writing that last while loop as a for loop. Do not use 
    // any information about the number of nodes. 
} 

Esto es todavía un largo camino, fuera de proporcionar encapsulación de datos adecuada, gestión de memoria, etc. Haciendo una clase de lista enlazada es adecuado no fácil. Es por eso que la biblioteca estándar proporciona uno. No reinventar la rueda.