C++ Forward Iterators tutorial with code examples

In C++, Forward Iterators are a type of iterator that allows reading and writing in a sequence, moving in one direction (forward).

Forward iterators are more flexible than input and output iterators since they allow multiple passes over the same elements, making them useful in algorithms where elements need to be accessed multiple times.

Forward iterators are widely used with containers such as std::forward_list, std::unordered_set, and std::unordered_map.

Characteristics of Forward Iterators

1. Single-direction traversal: Move forward only.
2. Multi-pass: Can iterate over the same range multiple times.
3. Readable and writable: Can read from and write to the elements.
4. Equality comparison: Can be compared for equality or inequality.

1. Basic Example with std::forward_list

The std::forward_list container uses forward iterators by default, as it only allows forward traversal.

#include <iostream>
#include <forward_list>
using namespace std;

int main() {
    forward_list<int> numbers = {1, 2, 3, 4, 5};

    // Forward iterator to traverse and print elements
    for (auto it = numbers.begin(); it != numbers.end(); ++it) {
        cout << *it << " ";
    }

    return 0;
}

Explanation:

• numbers.begin() and numbers.end() return forward iterators for std::forward_list.
• *it dereferences the iterator to access the element, and ++it moves to the next element.

Output:

1 2 3 4 5

2. Using std::advance to Move Forward Iterators

You can use std::advance to move forward iterators by a specific number of positions.

#include <iostream>
#include <forward_list>
#include <iterator>
using namespace std;

int main() {
    forward_list<int> numbers = {10, 20, 30, 40, 50};

    auto it = numbers.begin();
    advance(it, 3); // Move iterator 3 positions forward

    cout << "Element at position 3: " << *it << endl;

    return 0;
}

Explanation:

• advance(it, 3); moves the iterator it forward by three positions in the list.
• *it dereferences the iterator to access the element at the new position.

Output:

Element at position 3: 40

3. Modifying Elements with Forward Iterators

Since forward iterators allow writing, you can modify elements in a container.

#include <iostream>
#include <forward_list>
using namespace std;

int main() {
    forward_list<int> numbers = {1, 2, 3, 4, 5};

    // Modify each element by doubling its value
    for (auto it = numbers.begin(); it != numbers.end(); ++it) {
        *it *= 2; // Multiply each element by 2
    }

    cout << "Doubled elements: ";
    for (int number : numbers) {
        cout << number << " ";
    }

    return 0;
}

Explanation:

• *it *= 2; doubles each element in numbers by modifying the dereferenced iterator.

Output:

Doubled elements: 2 4 6 8 10

4. Finding an Element with std::find and Forward Iterators

std::find uses forward iterators to search for an element in a container.

#include <iostream>
#include <forward_list>
#include <algorithm>
using namespace std;

int main() {
    forward_list<int> numbers = {10, 20, 30, 40, 50};

    // Find the element 30
    auto it = find(numbers.begin(), numbers.end(), 30);

    if (it != numbers.end()) {
        cout << "Element 30 found!" << endl;
    } else {
        cout << "Element not found!" << endl;
    }

    return 0;
}

Explanation:

• find searches for 30 in numbers using forward iterators.
• If the element is found, it points to that element; otherwise, it points to numbers.end().

Output:

Element 30 found!

5. Inserting Elements in std::forward_list Using Forward Iterators

std::forward_list has a special function insert_after to insert elements since it only supports forward iterators.

#include <iostream>
#include <forward_list>
using namespace std;

int main() {
    forward_list<int> numbers = {1, 3, 4, 5};

    // Insert element after the first position
    auto it = numbers.begin();
    numbers.insert_after(it, 2); // Insert 2 after 1

    cout << "List after insertion: ";
    for (int number : numbers) {
        cout << number << " ";
    }

    return 0;
}

Explanation:

• insert_after(it, 2); inserts 2 after the first element using a forward iterator.

Output:

List after insertion: 1 2 3 4 5

6. Removing Elements with remove and Forward Iterators

The remove algorithm can use forward iterators to remove specific elements from a container.

#include <iostream>
#include <forward_list>
#include <algorithm>
using namespace std;

int main() {
    forward_list<int> numbers = {1, 2, 3, 2, 4, 2, 5};

    // Remove all occurrences of 2
    numbers.remove(2);

    cout << "List after removing 2s: ";
    for (int number : numbers) {
        cout << number << " ";
    }

    return 0;
}

Explanation:

• remove removes all occurrences of 2 from numbers.

Output:

List after removing 2s: 1 3 4 5

7. Counting Elements with std::count and Forward Iterators

The std::count function can use forward iterators to count occurrences of an element.

#include <iostream>
#include <forward_list>
#include <algorithm>
using namespace std;

int main() {
    forward_list<int> numbers = {1, 2, 3, 2, 4, 2, 5};

    int count_2 = count(numbers.begin(), numbers.end(), 2);

    cout << "Number of times 2 appears: " << count_2 << endl;

    return 0;
}

Explanation:

• count(numbers.begin(), numbers.end(), 2); counts the number of occurrences of 2 using forward iterators.

Output:

Number of times 2 appears: 3

8. Using Forward Iterators with std::unordered_set

std::unordered_set uses forward iterators, allowing you to iterate through elements in an arbitrary order.

#include <iostream>
#include <unordered_set>
using namespace std;

int main() {
    unordered_set<string> fruits = {"apple", "banana", "cherry"};

    cout << "Fruits in the unordered set: ";
    for (auto it = fruits.begin(); it != fruits.end(); ++it) {
        cout << *it << " ";
    }

    return 0;
}

Explanation:

• unordered_set<string> uses forward iterators to iterate over fruits in an arbitrary order.

Output:

Fruits in the unordered set: banana apple cherry

9. Using Forward Iterators with std::unordered_map

std::unordered_map also uses forward iterators, allowing you to iterate through key-value pairs.

#include <iostream>
#include <unordered_map>
using namespace std;

int main() {
    unordered_map<int, string> students = {{1, "Alice"}, {2, "Bob"}, {3, "Charlie"}};

    cout << "Student IDs and names: ";
    for (auto it = students.begin(); it != students.end(); ++it) {
        cout << it->first << ": " << it->second << ", ";
    }

    return 0;
}

Explanation:

• unordered_map<int, string> uses forward iterators to iterate over key-value pairs in students.

Output:

Student IDs and names: 1: Alice, 2: Bob, 3: Charlie,

10. Resetting a Forward Iterator to the Beginning

Forward iterators can be reset by reassigning them to container.begin().

#include <iostream>
#include <forward_list>
using namespace std;

int main() {
    forward_list<int> numbers = {1, 2, 3, 4, 5};

    // First pass
    cout << "First pass: ";
    for (auto it = numbers.begin(); it != numbers.end(); ++it) {
        cout << *it << " ";
    }
    cout << endl;

    // Reset and make a second pass
    auto it = numbers.begin();
    cout << "Second pass: ";
    while (it != numbers.end()) {
        cout << *it << " ";
        ++it;
    }

    return 0;
}

Explanation:

• Forward iterators can be reassigned to numbers.begin() to iterate over the container again.

Output:

First pass: 1 2 3 4 5
Second pass: 1 2 3 4 5

Summary Table of Forward Iterator Usage

Key Takeaways

• Forward Iterators allow reading and writing in one direction, making them versatile for containers that need single-direction traversal.
• They are multi-pass iterators, meaning they can make multiple passes over the same sequence.
• Containers like std::forward_list, std::unordered_set, and std::unordered_map use forward iterators.
• Forward iterators are compatible with STL algorithms like std::find, std::count, and std::advance, making them suitable for both searching and modifying container elements.