Introduction to Iterators in C++

An iterator is an object like a pointer that points to an element inside the container. We can use iterators to move through the contents of the container. They can be visualized as something similar to a pointer pointing to some location and we can access the content at that particular location using them.

Example:

#include <bits/stdc++.h>
using namespace std;

int main() {
    vector<int> v = {1,2,3,4,5};
    
    // Get the iterator of first element
    // of the vector
    vector<int>::iterator it = v.begin();
    
    // Print the content of location which is 
    // pointed by iterator (it)
    cout << *it;
    return 0;
}

1

Explanation: The above example demonstrates accessing the first element of a vector container by first obtaining its iterator (it). Then dereference this iterator with the asterisk (*) operator, which outputs the value 1.

Syntax

cType::iterator iteratorName;

where,

• cType: Container type.
• iteratorName: Named assign to the iterator.

We can use auto keyword to skip to write container type because auto keyword automatically detected container type itself.

auto iteratorName;

Types of Iterators

All iterators do not have similar functionality, depending upon the functionality of iterators they can be classified into five categories:

1. Input Iterator
2. Output Iterator
3. Forward Iterator
4. Bidirectional Iterator
5. Random-Access Iterator

Not all of these iterators are supported by all containers in STL. Different containers support different iterators, like vectors support random-access iterators, while lists support bidirectional iterators. The whole list is as given below:

The following diagram shows the difference in their functionality with respect to various operations that they can perform.

To know more, refer to the article - Iterators in C++

Iterators vs Pointers

The main differences between Iterators and Pointers are given in the below table:

Advantages of Iterators

There are following advantages of iterators listed below:

• Pointer Like Behavior: If we have worked with pointers in C++, iterators will feel pretty familiar. We can increment them, dereference them to get the value, and compare them, just like pointers—making them easy to use and understand.
• Easy Traversal: We don’t have to manually manage indices or worry about going out of bounds. Using basic operations like ++ and *, we can move through containers without a second thought.
• Use in STL Algorithm: The C++ Standard Library has a bunch of useful algorithms like sort, find, and accumulate that work seamlessly with iterators. This means we can apply these algorithms to any container, and the iterator handles all the internal stuff for us.
• Optimize for Task: C++ gives different types of iterators, like forward, bidirectional, and random access. These options let we pick the right one for the job, which can lead to more efficient code if you know what you need.
• Reverse Traversal: When we need to loop through a container in reverse order, iterators make it easy. We don’t have to manually adjust the order of the elements; we can simply use a reverse iterator to go through the container backwards.