Use of iterators over array indices

All of the standard containers provide the iterator concept. An iterator knows how to find the next element in the container, especially when the underlying structure isn't array-like. Array-style operator[] isn't provided by every container, so getting in the habit of using iterators will make more consistent-looking code, regardless of the container you choose.

You can abstract the collection implementation away.

To expand upon previous answers:

1. Writing a loop with operator[] constrains you to a container that supports [] and uses the same index/size type. Otherwise you'd need to rewrite every loop to change the container.

2. Even if your container supports [], it may not be optimal for sequential traversing. [] is basically a random-access operator, which is O(1) for vector but could be as bad as O(n) depending on the underlying container.

3. This is a minor point, but if you use iterators, your loop could be more easily moved to using the standard algorithms, e.g. std::for_each.

There are many data structures, e.g. hash tables and linked lists cannot be naturally or quickly indexed, but they are indeed traversable. Iterators act as an interface that let you walk on any data structure without knowing the actual implementation of the source.

The STL contains algorithms, such as transform and for_each that operate on containers. They don't accept indices, but use iterators.

Iterators help hide the container implementation and allow the programmer to focus more on the algorithm. The for_each function can be applied to anything that supports a forward iterator.

As well as the points in other answers, iterators can also be faster (specifically compared to operator[]), since they are essentially iteration by pointer. If you do something like:

for (int i = 0; i < 10; ++i)
{
    my_vector[i].DoSomething();
}

Every iteration of the loop unnecessarily calculates my_vector.begin() + i. If you use iterators, incrementing the iterator means it's already pointing to the next element, so you don't need that extra calculation. It's a small thing, but can make a difference in tight loops.

One other slight difference is that you can't use erase() on an element in a vector by index, you must have an iterator. No big deal since you can always do "vect.begin() + index" as your iterator, but there are other considerations. For example, if you do this then you must always check your index against size() and not some variable you assigned that value.

None of that is really too much worth worrying about but if given the choice I prefer iterator access for the reasons already stated and this one.

I would say it's more a matter of consistency and code reuse.

• Consistency in that you will use all other containers with iterators
• Code reuse in that algorithms written for iterators cannot be used with the subscript operator and vice versa... and the STL has lots of algorithms so you definitely want to build on it.

Finally, I'd like to say that even C arrays have iterators.

const Foo* someArray = //...
const Foo* otherArray = new Foo[someArrayLength];

std::copy(someArray, someArray + someArrayLength, otherArray);

The iterator_traits class has been specialized so that pointers or a model of RandomAccessIterator.