Working with Iterators

An iterator is only useful if you can get hold of one. Before you can walk through the elements of a collection, or work with one particular element, you need an iterator that refers to that element. This section answers a single question: where do iterators come from?

The answer is that iterators come from two situations. The first is when you first encounter a container. The second is when you call an algorithm. Keep these two sources in mind as you read, because the rest of this section examines each one in turn.

The first source is the container itself. When you first encounter a container, you can obtain iterators directly from it. The source gives begin() and end() as its examples of this kind of iterator.

The wording the source uses is precise. These iterators refer to useful elements. The point is not that a container hands you a copy of its contents. Instead, the container hands you iterators that point into it. Any later work you do with those iterators is work on the container's own elements.

The diagram is a schematic and is not a full specification. The source names begin() and end() as the examples to learn from, and it does not spell out their exact positions. Treat the boundary placement of end() as something to confirm when you study the container's elements in detail. What this section establishes is the shape of the exchange: the container gives you an iterator, and that iterator is what you use next.

The second source is the return value of an algorithm. The standard algorithm find looks for a value in a sequence. When it succeeds, it returns an iterator to the element it found.

This matters because the result of find is not merely a report that the value exists. It is a position you can use to work with that element. The iterator is the handle you then apply to the element.

The trace below uses a generic sequence of four elements and a value you are searching for. The steps describe the successful case that the source explains. The source does not describe what find returns when the value is missing, so this trace does not claim anything about that case.

The two sources answer different situations. When you first encounter a container and want to work through its elements, the iterator comes directly from the container. When you call an algorithm such as find to locate a value, the iterator comes back as the algorithm's return value. The table below sets the two sources side by side.

When you face a task, you can predict the source by asking one question: does the task begin with a search for a particular value? If so, the iterator you need is the one an algorithm returns. If the task starts from the container itself, you ask the container for its iterators. The flowchart below turns this into a sequence of decisions.