C++ Ranges Library Cheat Sheet

Views, adaptors, and pipe-composed algorithms from std::ranges (C++20/23) for lazy, composable iteration without manual iterator pairs.

2 PagesAdvancedFeb 20, 2026

Basic Range Algorithms

std::ranges algorithms take a range directly, no begin()/end() pair needed.

cpp

#include <ranges>#include <algorithm>#include <vector>#include <iostream>std::vector<int> v{5, 3, 1, 4, 2};std::ranges::sort(v);                              // sorts in place, no v.begin(), v.end()auto it = std::ranges::find(v, 3);                    // returns iteratorbool any = std::ranges::any_of(v, [](int x) { return x > 4; });auto [min_it, max_it] = std::ranges::minmax_element(v);

Lazy Views & Pipe Syntax

Views are lazy, non-owning, composable with the | operator.

cpp

#include <ranges>#include <vector>std::vector<int> nums{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};auto result = nums    | std::views::filter([](int n) { return n % 2 == 0; })    | std::views::transform([](int n) { return n * n; })    | std::views::take(3);for (int x : result) {   // 4, 16, 36 -- computed lazily on iteration    std::cout << x << ' ';}// Common views: filter, transform, take, drop, reverse, join, split,// take_while, drop_while, iota, enumerate (C++23), zip (C++23)

Materializing & C++23 additions

Convert a view back into a concrete container; ranges::to arrives in C++23.

cpp

#include <ranges>#include <vector>auto view = std::views::iota(1, 11)    | std::views::filter([](int n) { return n % 3 == 0; });// C++23: ranges::to converts a view into a containerstd::vector<int> multiples_of_3 = view | std::ranges::to<std::vector>();// Pre-C++23: construct explicitlystd::vector<int> manual(view.begin(), view.end());// C++23: views::enumerate and views::zipfor (auto [i, x] : std::views::enumerate(multiples_of_3)) {    std::cout << i << ": " << x << '\n';}

Concepts & Constrained Algorithms

Ranges algorithms are constrained by concepts, giving better compile errors.

cpp

#include <ranges>#include <concepts>template <std::ranges::input_range R>    requires std::equality_comparable<std::ranges::range_value_t<R>>bool contains(R&& r, const std::ranges::range_value_t<R>& value) {    return std::ranges::find(r, value) != std::ranges::end(r);}// Projections: transform elements before comparison without a full transform viewstruct Person { std::string name; int age; };std::vector<Person> people{{"Bob", 30}, {"Ann", 25}};std::ranges::sort(people, std::ranges::less{}, &Person::age);  // sort by age via projection

Common View Adaptors

The most frequently used entries in std::views.

views::filter(pred)- keep elements where pred returns true
views::transform(f)- lazily apply f to each element
views::take(n) / drop(n)- first n elements / skip first n
views::reverse- iterate in reverse order
views::split(delim)- split a range into subranges (C++20, refined in C++23)
views::join- flatten a range of ranges
views::iota(start[, end])- generate an infinite or bounded arithmetic sequence
views::zip(r1, r2, ...)- iterate multiple ranges in lockstep (C++23)

Pro Tip

Views are lazy and non-owning — never return a view that references a local container by value from a function; the container is destroyed on return and the view becomes a dangling reference, a very easy trap to fall into with pipe chains.

Was this cheat sheet helpful?

Python Pattern Matching (match/case) Cheat Sheet

C++ Coroutines Cheat Sheet