Opérateur d'incrémentation/ itérateur de mise en œuvre

Je suis à essayer de comprendre deux choses ici:

  1. Comment puis-je écrire un opérateur d'incrémentation pour une classe de nœud qui a un pointeur vers le nœud suivant?
  2. Comment puis-je mettre en œuvre les 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 d'opérateur ou d'itérateurs.

Vous ne pouvez pas. la tête est un pointeur et ++ opérateur est builtin/défini pour les pointeurs. Si la tête est celle d'un objet ou d'une référence à un objet, alors vous pourriez le faire.
hmm..ok. Connaissez-vous des liens vers des textes itérateurs? Merci
Vous pouvez consulter les réponses à cette question: stackoverflow.com/questions/3582608/...
comme vous l'avez suggéré découlant STL itérateurs j'étais en train de regarder l'exemple à cplusplus.com/reference/std/iterator/iterator. Donc, si je veux lire et à écrire, dois-je simplement utiliser random_access_iterator_tag ? ou recommandez-vous?
Je recommande de commencer à partir de boost::iterator_facade, qui permet de fournir une partie de l'infrastructure que de la bonne itérateurs besoin. Il a même un tutoriel qui va avec.

OriginalL'auteur blueskin | 2010-12-01

  1. 11

    Vous ne mettez pas en œuvre operator++ pour la classe de Nœud; mettre en œuvre pour l'itérateur. La classe iterator devrait être une classe à part.

    Et s'il vous plaît, ne gâchez pas votre modèle en faisant des hypothèses (depuis val est un T, votre constructeur doit accepter un T, pas un int). Aussi, ne pas ignorer le int paramètre de l'opérateur++ comme ça: c'est un mannequin utilisé pour distinguer la pré-incrémentation de la mise en œuvre de la post-incrémentation de la mise en œuvre.

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

    C'est encore un long, long chemin de fournir une encapsulation des données, gestion de la mémoire etc. Faire une bonne liste liée classe est pas facile. C'est pourquoi la bibliothèque standard fournit un. Ne pas réinventer la roue.

    J'ai réalisé qu'après cette annonce. J'étais en train d'essayer de comprendre comment mettre en œuvre les itérateurs, c'est un mauvais exemple que j'ai donné. Je pense que QList est bien mis en oeuvre qu'liste STL. Je vais essayer de mettre en place quelque chose comme ça. Merci Karl
    en.literateprograms.org/Singly_linked_list_%28C_Plus_Plus%29 est plus utile
    Pourquoi ne opérateur++() renvoie une référence const et l'opérateur++(int) renvoie une valeur?
    Je ne sais pas pour vous, mais je pense que c'est parce que dans la post-incrémentation, vous devez retourner la valeur qui existait avant l'incrémentation, alors que la pré-incrémentation retourne const référence à l'itérateur parce qu'il est utilisé uniquement pour l'avancement de l'itérateur. Notez que la post-incrémentation utilise également pré-incrémentation à l'avance l'itérateur.
    vous avez tout à fait raison.

    OriginalL'auteur Karl Knechtel