Iterators as Generalized Pointers
It may not be obvious at first, but you can think of an iterator as a generalized pointer. Imagine a pointer to an array of int s. The array itself is a collection class, and a pointer to an element of that array is a random-access iterator. To advance to the next element, you simply use the unary operator ++. To move back to a previous element, you use --. To access the element at the current position of the iterator, you use the unary operator *. Finally, it is important to know when you have visited all the elements. C++ guarantees that you can always point to the first address past the end of an allocated array. For example:
int intCollection[10]; // an array of integers
// ... < put stuff in the array >
// position iter at start:
int* iter = intCollection;
// set another iterator past the end:
int* theEnd = intCollection + 10;
// iterate through, looking for a 7:
while (iter != theEnd) { // test for end of array
if (*iter == 7) // use '*' to access current element
return true; // found a 7
++iter; // not a 7, try next element
}
return false; // never found a 7
If you compare this code fragment to the one using standard iterators in
C++ Standard Library Iterators, you can see the similarities. If you need a bit of help imagining how the standard iterators work, you can always picture them as generalized pointers.
