Ranges, views, and lazy pipelines

Understanding Ranges, views, and lazy pipelines

A range is anything std::ranges::begin and std::ranges::end work on, which is why the std::ranges:: algorithms take the container as a single argument. A view is a range that refers to elements it does not own and that can be copied in constant time; std::views::filter, transform, take, drop and reverse are factories that wrap an existing range in a new view type. The pipe is only a spelling convenience: v | std::views::filter(p) | std::views::transform(f) constructs a transform_view wrapping a filter_view wrapping a ref_view, an object holding nothing but a pointer to v, copies of the two callables, and a slot for caching where filtering starts. Constructing it reads no elements at all.

The actual work lives in the iterators of those wrapper types. Dereferencing a transform_view iterator calls f on the current underlying element and returns the result by value; incrementing a filter_view iterator runs a find_if forward through the source until the predicate holds again. Consumption pulls from the far end of the chain: the range-for asks take_view for an element, take_view asks transform_view, which asks filter_view, which finally advances a vector iterator. Nothing is buffered between stages, so the chain makes a single pass and touches only the elements you actually consume, which is why a pipeline ending in take(5) can sit on top of an unbounded views::iota.

Two consequences follow from a view storing a reference and no results. First, the pipeline is valid only while its source lives and its iterators stay valid, so a view built over a local container and returned from a function dangles exactly like a returned pointer. Second, iterating the same pipeline twice re-runs every predicate and every transform, because nothing was memoized, and the adaptors weaken what the range can promise: a filtered view has no size() and no [i], and cannot be passed to ranges::sort. When you need any of that, end the pipeline by copying it into a real container.

#include <iostream>
#include <ranges>
#include <vector>

int main() {
    std::vector<int> v{5, 2, 9, 1, 7, 4, 8};
    int tested = 0;

    auto scaled_odds = v
        | std::views::filter([&tested](int n) { ++tested; return n % 2 == 1; })
        | std::views::transform([](int n) { return n * 10; });

    std::cout << "tested after building the pipeline: " << tested << '\n';

    for (int n : scaled_odds | std::views::take(2))
        std::cout << "got " << n << '\n';

    // 4, not 7: the loop wanted two values, and the last ++ had already
    // scanned past 9 to the next odd element before take's counter hit zero.
    std::cout << "tested after consuming two values: " << tested << '\n';
}

Worked examples

#include <iostream>
#include <ranges>

int main() {
    auto squares = std::views::iota(1)
        | std::views::transform([](int n) { return n * n; })
        | std::views::filter([](int n) { return n % 3 == 1; })
        | std::views::take(5);

    for (int n : squares)
        std::cout << n << '\n';
}

#include <algorithm>
#include <iostream>
#include <iterator>
#include <ranges>
#include <string>
#include <vector>

int main() {
    std::vector<std::string> names{"ada", "grace", "alan", "edsger", "barbara"};

    auto initials = names
        | std::views::filter([](const std::string& s) { return s.size() > 3; })
        | std::views::transform([](const std::string& s) { return s.front(); });

    std::vector<char> letters;
    std::ranges::copy(initials, std::back_inserter(letters));

    std::cout << "view length: " << std::ranges::distance(initials) << '\n';
    std::cout << "letters: ";
    for (char c : letters) std::cout << c;
    std::cout << '\n';

    std::ranges::sort(letters);       // fine: letters owns its chars
    // std::ranges::sort(initials);   // ill-formed: not random-access, elements are temporaries
    std::cout << "sorted: ";
    for (char c : letters) std::cout << c;
    std::cout << '\n';
}

Important notes

Common mistakes

Try it yourself