LESSON 20 · INTERMEDIATE4 min read

Custom Iterator Contracts, Range-Based For Loops, and STL Compatibility

Implement custom STL-compliant forward and random-access iterators: iterator traits, begin()/end() contracts, pointer arithmetic operators, and range-based for loops.

C++20 / C++23Free to readModule 5 of 11

YOUR NEXT SMALL WINS

By the end, you’ll be able to…

Implement a custom iterator struct conforming to STL iterator category concepts
Enable range-based for loops (for (auto& item : container)) by exposing begin() and end()
Distinguish between Forward, Bidirectional, and Random-Access iterator capabilities

01The STL Iterator Abstraction

The genius of the Standard Template Library (STL) lies in decoupling algorithms from containers. Algorithms like std::sort, std::find, and std::transform do not know how std::vector, std::list, or custom containers are laid out in memory.

Instead, algorithms interact exclusively through Iterators—generalized pointer-like objects that traverse sequences. By equipping custom containers with standard iterator interfaces, your classes instantly gain access to over 100 optimized algorithms in <algorithm> and support modern C++ range-based for loops.

To support range-based for loops (for (auto& elem : my_container)), a container only needs to provide two member functions: begin() (returning an iterator to the first element) and end() (returning an iterator one past the final element).

example.js⚙️C++

Ctrl + ↵

#include <iostream>
#include <iterator>
#include <algorithm>

template <typename T, size_t N>
class SimpleArray {
private:
    T data_[N];
public:
    // Custom Iterator nested class
    class Iterator {
    public:
        using iterator_category = std::random_access_iterator_tag;
        using value_type        = T;
        using difference_type   = std::ptrdiff_t;
        using pointer           = T*;
        using reference         = T&;

explicit Iterator(pointer ptr) : ptr_(ptr) {}

reference operator*() const noexcept { return *ptr_; }
        pointer operator->() const noexcept { return ptr_; }

// Prefix increment (++it)
        Iterator& operator++() noexcept { ++ptr_; return *this; }
        // Postfix increment (it++)
        Iterator operator++(int) noexcept { Iterator tmp = *this; ++ptr_; return tmp; }

friend bool operator==(const Iterator& a, const Iterator& b) noexcept { return a.ptr_ == b.ptr_; }
        friend bool operator!=(const Iterator& a, const Iterator& b) noexcept { return a.ptr_ != b.ptr_; }
    private:
        pointer ptr_;
    };

Iterator begin() noexcept { return Iterator(&data_[0]); }
    Iterator end() noexcept { return Iterator(&data_[N]); }
};

Output

Click Run or press Ctrl+Enter

Output will appear here after you run the code.

02Iterator Categories: From Input to Random Access

The C++ standard defines a strict hierarchy of iterator categories based on traversal capabilities:

1. Input / Output Iterator: Single-pass, read-only or write-only traversal (e.g., std::istream_iterator).

2. Forward Iterator: Multi-pass traversal in a forward direction (operator++, operator*). Can be used in std::find.

3. Bidirectional Iterator: Can traverse forward and backward (operator++, operator--). Used in std::list and std::map.

4. Random-Access Iterator: Can jump in O(1) time by arbitrary offsets (it + n, it[n], it1 - it2). Required by std::sort.

03Standard Iterator Traits and Type Aliases

To be fully recognized by STL algorithms, an iterator must expose five standard type aliases: iterator_category, value_type, difference_type, pointer, and reference.

In C++20, the Concepts library formalized these contracts with std::input_iterator, std::forward_iterator, and std::random_access_iterator concepts. If a custom iterator provides operator* and operator++, the compiler can verify compliance at compile time without legacy std::iterator inheritance.

04Iterator Hierarchy Comparison Matrix

Understanding capabilities across standard iterator categories:

Providing random-access iterators enables high-performance parallel sorting and binary searching.

notes.txtPlain text

+-----------------------+---------------------+-------------------+------------------------+| Iterator Category     | Operators Required  | Access Time       | Example Container      |+-----------------------+---------------------+-------------------+------------------------+| Forward Iterator      | ++, *, ==, !=       | O(N) linear       | std::forward_list      || Bidirectional Iterator| ++, --, *, ==, !=   | O(N) linear       | std::list, std::map    || Random Access Iterator| ++, --, +, -, [], < | O(1) constant jump| std::vector, std::deque|| Contiguous (C++20)    | Elements contiguous | O(1) + cache-line | std::vector, std::array|+-----------------------+---------------------+-------------------+------------------------+

05Production Systems Architecture & Hardware Trade-Offs

From an operating system and hardware architecture perspective, systems software must account for physical execution realities that compiler abstractions intentionally hide. At the hardware level, instruction caches (I-Cache) and data caches (D-Cache) operate independently, and CPU pipeline front-ends rely heavily on branch target buffers (BTB) to minimize instruction fetch stalls. When code is organized into coherent, spatially contiguous blocks within translation units, binary code density increases, improving instruction cache hit rates across high-frequency execution loops.

Furthermore, modern linkers such as LLVM lld and mold perform Link-Time Optimization (LTO) across translation units. When LTO is enabled (-flto), the compiler writes LLVM bitcode into object files rather than final machine code, allowing the linker to perform cross-translation-unit function inlining, devirtualization, and dead-code stripping across the entire binary.

LET IT CLICK

The ideas worth keeping.

Iterators decouple algorithms from container memory layout, unlocking the STL algorithms library.
Expose begin() and end() to enable seamless modern range-based for loops.
Always prefer prefix ++it over postfix it++ to eliminate temporary iterator copies.

TURN UNDERSTANDING INTO SOMETHING YOU CAN DO

Make it yours.

Type and test your code right here in the interactive workspace. Run your solution, check the output, and compare with the worked guide when ready.

Exercise 1: Write a range based for loop over a SimpleArr

Write a range-based for loop over a SimpleArray<int, 5> container and explain what code the compiler expands it into.

your_turn_1.cpp⚙️C++

Ctrl + ↵

Output

Click Run or press Ctrl+Enter

Output will appear here after you run the code.

Explore a worked solution

one_possible_solution.cppC++

// User code:SimpleArray<int, 5> arr;for (auto& x : arr) {    x = 10;}// Compiler expansion:{    auto&& __range = arr;    auto __begin = __range.begin();    auto __end = __range.end();    for (; __begin != __end; ++__begin) {        auto& x = *__begin;        x = 10;    }}

The compiler expands range-based for into an explicit loop over begin() and end() with ++ and *.

Exercise 2: What is the difference between prefix operato

What is the difference between prefix operator++ and postfix operator++(int) in custom iterator design?

your_turn_2.cpp⚙️C++

Ctrl + ↵

Output

Click Run or press Ctrl+Enter

Output will appear here after you run the code.

Explore a worked solution

one_possible_solution.cppC++

// Prefix (++it) increments the iterator and returns *this by reference (zero copies).// Postfix (it++) takes an int dummy parameter, creates a temporary copy of the old state,// increments *this, and returns the old copy by value.// In loops, prefer prefix (++it) to avoid unnecessary temporary copy overhead.

Postfix must take a dummy int parameter and return a copy of the previous state.

Keep exploring.

The official references behind this lesson, when you want a second angle or the full details.

MODULE 05 · PRACTICAL SELF-CHECK

Pause. Put the pieces together.

You’ve reached the end of Class Design, Operator Overloading, and Custom Iterators. Before moving on, use this task to check what you can do independently.

Overload arithmetic and stream operators and expose STL-compliant iterator interfaces.

Try it in your own environment and write down the result. This is a self-check; reading completion does not evaluate your code.

Review this module

One lesson closer.

Reading is a start. Trying it yourself makes the connection.

Solve the hands-on coding challenge in the knowledge section to verify your code and unlock lesson completion.

By the end, you’ll be able to…

01The STL Iterator Abstraction

02Iterator Categories: From Input to Random Access

03Standard Iterator Traits and Type Aliases

04Iterator Hierarchy Comparison Matrix

05Production Systems Architecture & Hardware Trade-Offs

The ideas worth keeping.

Make it yours.

Exercise 1: Write a range based for loop over a SimpleArr

Exercise 2: What is the difference between prefix operato

What stayed with you?

Exercise 1: Write a range based for loop over a SimpleArr

Keep exploring.

Pause. Put the pieces together.

One lesson closer.