opérateur Increment/mise en œuvre iterator

Question

J'essaie de trouver un ou deux choses:

1. Comment puis-je écrire un opérateur d'incrément pour une classe de noeud qui a un pointeur vers le nœud suivant?

2. Comment implémenter des itérateurs pour une classe comme ci-dessous?

   #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;? 
       } 
   } 
   

Ce n'est pas un bon exemple pour démontrer la surcharge des opérateurs ou itérateurs.

Answer 1

Vous n'implémentez pas operator++ pour la classe de nœud; vous l'implémentez pour l'itérateur. La classe itérateur doit être une classe distincte.

Et s'il vous plaît, ne pas gâcher votre modèle en faisant des hypothèses (depuis val est un T, votre constructeur devrait accepter un T, pas int). De plus, n'ignorez pas le paramètre int de l'opérateur ++ comme cela: c'est un mannequin utilisé pour distinguer l'implémentation de pré-incrémentation de l'implémentation post-incrément.

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. 
} 

Ceci est encore un long, loin de fournir l'encapsulation des données, une gestion de la mémoire, etc. Faire une classe de liste chaînée est correcte pas facile. C'est pourquoi la bibliothèque standard en fournit un. Ne réinventez pas la roue.