C++ Iterators

In C++, the iterator stands out as a potent and flexible tool available to programmers within the Standard Template Library (STL). It serves as a valuable mechanism facilitating seamless traversal between various containers like vectors, lists, maps, and sets, and algorithms. Essentially functioning as a pointer, the iterator aids developers in systematically navigating through container elements with precision and structure.

In C++, an iterator is a type of object that functions akin to a pointer by referencing a specific element within a container. This functionality enables programmers to navigate through the elements stored in the container. Essentially, an iterator can be viewed as a pointer that offers a wide range of functionalities. Iterators serve the same purpose as pointers for accessing elements within the container.

Syntax

It has the following syntax.

<ContainerType> :: iterator;  

<ContainerType> :: const_iterator;

Operations Performed on the Iterators

Iterators can perform several operations in C++. Some of the main operations are as follows:

• ✅ Operator (): The '' operator is used to return the element of the current position pointed by the iterator.
• ✅ Operator (++): The '++' operator increments the iterator by one. Therefore, an iterator points to the next element of the container.
• ✅ Operator (==) and Operator (!=): Both these operators determine whether the two iterators point to the same position or not.
• ✅ Operator (=): It is used to assign the iterator.

Features of the iterator in C++

There are several features of the iterators in C++. Some of them are as follows:

• ✅ Iterators are commonly utilized to traverse from one element to another element, a process known as iterating through the container.
• ✅ The main advantage of an iterator is to provide a common interface for all container types.
• ✅ Iterators make the algorithm independent of the type of container used.
• ✅ Iterators provide a generic approach to navigate through the elements of a container.

Types of Iterator in C++

An iterator can be categorized in the following ways. These are as follows:

• ✅ Input Iterator
• ✅ Output Iterator
• ✅ Forward Iterator
• ✅ Bidirectional Iterator
• ✅ Random Access Iterator

Next, we will examine each iterator individually within the context of C++.

1) Input Iterator:

In C++, an input iterator is a type of iterator that allows for accessing elements within a container without altering the container's values.

Several Operators can be utilized for an input iterator. These are as follows:

• ✅ Increment operator(++)
• ✅ Equal operator(==)
• ✅ Not equal operator(!=)
• ✅ Dereference operator(*)

C++ Input Iterator Example

Let's consider an example to showcase the input iterator in C++.

Example

#include <iostream>

#include <vector>

using namespace std;  //using standard namespace

int main() {  //main function

    vector<int> nums = {1, 2, 3, 4, 5};

    vector<int>::iterator it;

    cout << "Input Iterator Output: ";

    for (it = nums.begin(); it != nums.end(); ++it) {

        cout << *it << " ";

    }

    return 0;

}

Output:

Input Iterator Output: 1 2 3 4 5

2) Output Iterator

An output iterator in C++ is frequently employed to change the content of a container without retrieving the content from it. This makes an output iterator essentially a write-only iterator. Various operators associated with an output iterator include:

• ✅ Increment operator(++)
• ✅ Assignment operator(=)

C++ Output Iterator Example

Let's consider an example to showcase the output iterator functionality in C++.

Example

#include <iostream>

#include <vector>

#include <iterator>

using namespace std;  //using standard namespace

int main() {  //main function

    vector<int> v(5);

    vector<int>::iterator it = v.begin();

    int value = 1;

    for (; it != v.end(); ++it) {

        *it = value * 10;

        value++;

    }

    cout << "Output Iterator Result: ";

    for (auto x : v)

        cout << x << " ";

    return 0;

}

Output:

Output Iterator Result: 10 20 30 40 50

3) Forward Iterator

In C++, a forward iterator is an iterator used to read and write to a container. It is a multi-pass iterator. Several operators are used for a forward iterator. Some of them are as follows:

• ✅ Increment operator(++)
• ✅ Assignment operator(=)
• ✅ Equal operator(=)
• ✅ Not equal operator(!=)

C++ Forward Iterator Example:

Let's consider a scenario to showcase the forward iterator in C++.

Example

#include <iostream>

#include <forward_list>

using namespace std;   //using standard namespace

int main() {   //main function

    forward_list<int> fl = {100, 200, 300, 400};

    cout << "Forward Iterator Output: ";

    for (auto it = fl.begin(); it != fl.end(); ++it) {

        cout << *it << " ";

    }

    return 0;

}

Output:

Forward Iterator Output: 100 200 300 400

4) Bidirectional iterator

In C++, a bidirectional iterator is an iterator that supports all the features of a forward iterator and provides one more feature, i.e., the decrement operator(--). We can move backward by decrementing an iterator. Several operators commonly utilized for a Bidirectional iterator include:

• ✅ Increment operator(++)
• ✅ Assignment operator(=)
• ✅ Equal operator(=)
• ✅ Not equal operator(!=)
• ✅ Decrement operator(--)

C++ Bidirectional Iterator Example

Let's consider a scenario to demonstrate the bidirectional iterator concept in C++.

Example

#include <iostream>

#include <list>

using namespace std;  //using standard namespace

int main() {  //main function

    list<int> lst = {10, 20, 30, 40};

    cout << "Bidirectional Iterator Output (Forward): ";

    for (auto it = lst.begin(); it != lst.end(); ++it)

        cout << *it << " ";

    cout << "\nBidirectional Iterator Output (Backward): ";

    for (auto it = --lst.end(); ; --it) {

        cout << *it << " ";

        if (it == lst.begin()) break;

    }

    return 0;

}

Output:

Bidirectional Iterator Output (Forward): 10 20 30 40

Bidirectional Iterator Output (Backward): 40 30 20 10

5) Random Access Iterator

In C++, a Random Access iterator is an iterator that offers the capability to access an element at any position within the collection in a non-sequential manner. It encompasses all functionalities of a bidirectional iterator and extends its capabilities by enabling operations like pointer addition and subtraction for direct element access.

C++ Random Access Iterator Example:

Let's consider a scenario to demonstrate the Random Access Iterator in C++.

Example

#include <iostream>

#include <vector>

using namespace std;  //using standard namespace

int main() {   //main function

    vector<int> arr = {5, 10, 15, 20, 25};

    vector<int>::iterator it = arr.begin();

    cout << "Random Access Iterator Example:\n";

    cout << "First element: " << *it << endl;

    cout << "Third element: " << *(it + 2) << endl;

    cout << "Distance between begin and end: " << arr.end() - arr.begin() << endl;

    return 0;

}

Output:

Random Access Iterator Example:

First element: 5

Third element: 15

Distance between begin and end: 5

Iterators and Their Characteristics

Iterators can be employed for various operations that demonstrate their functionality. Below is a table outlining the retrieval method, traversal direction, and input/output capability of different iterator types.

C++ Example to traverse a vector using Iterators

Let's explore an illustration of iterating through a vector using iterators in C++.

Example

#include <iostream>  

#include<vector>  

#include<iterator>  

using namespace std;    //using standard namespace

int main()   //main function

{  

    vector<int> v{1,2,3,4,5};  

    vector<int>::iterator itr;  

    for(int i=0;i<5;i++)           // Traversal without using an iterator.  

    {  

        cout<<v[i]<<" ";  

    }  

    cout<<'\n';  

    for(itr=v.begin();itr!=v.end();itr++)  // Traversal by using an iterator.  

    {  

        cout<<*itr<<" ";  

    }  

    v.push_back(10);  

    cout<<'\n';  

     for(int i=0;i<6;i++)  

    {  

        cout<<v[i]<<" ";  

    }  

    cout<<'\n';  

     for(itr=v.begin();itr!=v.end();itr++)  

    {  

        cout<<*itr<<" ";  

    }  

     return 0;  

}

Output:

1 2 3 4 5

1 2 3 4 5

1 2 3 4 5 10

1 2 3 4 5 10

Explanation:

In this instance, it is evident that when iterating through the components of a vector without utilizing an iterator, it is essential to maintain a count of the elements inserted into the container.

Advantages of an Iterator in C++

There are several advantages of an iterator in C++. Some of them are as follows:

• ✅ It is convenient to use iterators rather than using a subscript operator to access the elements of a container.
• ✅ If we use the subscript operator to access the elements, we need to keep track of the number of elements added at runtime. However, it would not happen in the case of an iterator.
• ✅ If we use an iterator in C++, we can reuse the code. If we use iterators to access the elements, we can also access the list elements.
• ✅ C++ iterators provide the facility to add or delete data dynamically.

Disadvantages of an Iterator in C++

There are several disadvantages of the iterator in C++. Some of them are as follows:

• ✅ If we need to move from one data structure to another at the same time, iterators won't work.
• ✅ If we want to update the structure that is being iterated, an iterator won't allow us to do so because of the way it stores the position.
• ✅ If we need to backtrack while processing through a list, the iterator will not work in this case.

Conclusion

In summary, iterators play a crucial role in the C++ Standard Template Library (STL). They enable smooth navigation and modification of container elements, serving as a strong link between containers and algorithms. By utilizing iterators, developers can create code that is organized, can be reused, and performs effectively, all without needing to worry about the specific data structure being used.

Frequently Asked Questions

1) What is an iterator in C++?

In C++, an iterator is a tool that provides us with the ability to interact with items within a container, like a vector or a list, sequentially. Functioning akin to a pointer, the iterator enables navigation through each element housed in the container. Leveraging iterators, we can conveniently retrieve and modify container elements without necessitating knowledge of the data storage technique.

2) Why are iterators used in C++?

In C++, iterators provide a straightforward way to iterate through all the elements of a container. They provide a consistent and universal method to retrieve data, irrespective of the specific container type. This simplifies programming tasks and enhances the overall flexibility of coding.

3) How do we declare an iterator?

An iterator is defined similarly to declarations, with the inclusion of a container type followed by "::iterator". For instance, vector::iterator it; denotes that the iterator will reference an element contained within a vector.

4) What is the difference between the begin and end functions in C++?

In C++, the primary contrast between the begin and end functions lies in their purposes. The begin function is frequently employed to provide an iterator pointing to the initial element of the container, while the end function is typically used to yield the sentinel representing the position 'just past' the final element of the container.

5) Can we change values using the iterators?

Yes, by utilizing a non-const iterator, modifications to values can be made. Conversely, when employing a const_iterator, values can only be accessed for reading purposes, and alterations to the value "icpp tutorials" are prohibited. This feature enables the safeguarding of data in situations where modification is not intended.