Understanding Iterators in the STL

Question

What exactly are iterators in the C++ STL?

In my case, I\'m using a list, and I don\'t understand why you have to make an iterator std::list

Answer 1

An iterator is not the same as the container itself. The iterator refers to a single item in the container, as well as providing ways to reach other items.

Consider designing your own container without iterators. It could have a size function to obtain the number of items it contains, and could overload the [] operator to allow you to get or set an item by its position.

But "random access" of that kind is not easy to implement efficiently on some kinds of container. If you obtain the millionth item: c[1000000] and the container internally uses a linked list, it will have to scan through a million items to find the one you want.

You might instead decide to allow the collection to remember a "current" item. It could have functions like start and more and next to allow you to loop through the contents:

c.start();
while (c.more()) 
{
    item_t item = c.next();

    // use the item somehow
}

But this puts the "iteration state" inside the container. This is a serious limitation. What if you wanted to compare each item in the container with every other item? That requires two nested loops, both iterating through all the items. If the container itself stores the position of the iteration, you have no way to nest two such iterations - the inner loop will destroy the working of the outer loop.

So iterators are an independent copy of an iteration state. You can begin an iteration:

container_t::iterator i = c.begin();

That iterator, i, is a separate object that represents a position within the container. You can fetch whatever is stored at that position:

item_t item = *i;

You can move to the next item:

i++;

With some iterators you can skip forward several items:

i += 1000;

Or obtain an item at some position relative to the position identified by the iterator:

item_t item = i[1000];

And with some iterators you can move backwards.

And you can discover if you've reached beyond the contents of the container by comparing the iterator to end:

while (i != c.end())

You can think of end as returning an iterator that represents a position that is one beyond the last position in the container.

An important point to be aware of with iterators (and in C++ generally) is that they can become invalid. This usually happens for example if you empty a container: any iterators pointing to positions in that container have now become invalid. In that state, most operations on them are undefined - anything could happen!