列表的元素，并迭代到下一个元素

Question

I don't get what Bjarne has on mind stating:

A list iterator must be something more complicated than a simple pointer to an element because an element of a list in general does not know where the next element of that list is. Thus, a list iterator might be a pointer to a link

I know that list's node has pointers to the next and previous nodes. So how it "in general does not know"?

Answer 1

For contrast, let's consider an iterator for std::vector . Though you probably don't want to, you could basically implement it as a simple pointer:

template <class T>
class vector {
    T *data;
    size_t current_size;
    size_t alloc_size;
public:
    typedef T *iterator;
    iterator begin() { return data; }
    iterator end() { return data+current_size; }
    // ...
};

and since the data in the vector is contiguous, when you do (for example) ++ on the iterator, it would do the right thing (get you to the next item in the vector).

With a linked list, it can't be that simple though -- if you used typedef to make iterator an alias for T * , it wouldn't work right. When you tried to do ++ on the iterator, it would just increment the pointer, instead of taking you to the next element in the linked list like it needs to.

You need to build some intelligence into the iterator class so operator++ (for one example) knows to "chase" the pointer instead of just incrementing.

template <class T>
class list { 

    class node { 
        T data;
        node *next;
        node *prev;
    };
public:
    class iterator {
        node *pos;
    public:
        iterator operator++() {
            return pos = pos->next;
        }
        iterator operator--() {
            return pos = pos->prev;
        }
    };
};

Answer 2

Don't confuse list node with a list element. It might be a pointer, but to a node, which contains element and next/prev links. If it were just a pointer to the element, you wouldn't be able to move around with it. (Though it's unlikely to be just pointer, since it typically has to overload operator++ to fetch next pointer instead of incrementing itself).

This isn't true for intrusive lists, where node == element, but that's not std::list.

// illustrative
template <typename ElementType>
struct list_node {
    ElementType element;
    list_node *next, *prev;
};