Inkrementoperator/Iterator Implementierung

Question

ich versuche, hier ein paar Dinge, um herauszufinden:

1. Wie schreibe ich einen Inkrementoperator für eine Knotenklasse, die einen Zeiger auf den nächsten Knoten hat?

2. Wie implementiere ich Iteratoren für eine Klasse wie unten?

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

Diese für den Nachweis der Betreiber Überlastung oder Iteratoren nicht ein gutes Beispiel ist.

Answer 1

Sie implementieren operator++ nicht für die Knotenklasse; Sie implementieren es für den Iterator. Die Iterator-Klasse sollte eine separate Klasse sein.

Und bitte nicht verderben Ihre Vorlage Annahmen, indem sie (da val ein T ist, Konstruktor sollte eine T akzeptieren, kein int). Ignorieren Sie auch nicht den int-Parameter für den Operator ++: Es handelt sich um einen Dummy, der die Vorinkrement-Implementierung von der Post-Inkrement-Implementierung unterscheidet.

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

Dies ist noch ein langer usw. langer Weg richtige Datenkapselung von der Bereitstellung, Speicherverwaltung eine richtige verkettete Liste Klasse zu machen ist nicht einfach. Aus diesem Grund bietet die Standardbibliothek eins. Erfinde das Rad nicht neu.