C++ Ranges Cheat Sheet

namespace views = std::views;

auto result = container
    | views::filter(pred)
    | views::transform(fn)
    | views::take(n);

for (auto x : result) { /* lazy evaluation */ }

// Sorting & searching
std::ranges::sort(v);
std::ranges::sort(v, std::greater{});
std::ranges::sort(v, {}, &S::field);     // projection
std::ranges::stable_sort(v);
std::ranges::nth_element(v, v.begin()+n);
std::ranges::partial_sort(v, v.begin()+n);

// Finding
std::ranges::find(v, value);
std::ranges::find_if(v, pred);
std::ranges::find_if_not(v, pred);
std::ranges::binary_search(v, value);    // sorted range
std::ranges::lower_bound(v, value);
std::ranges::upper_bound(v, value);
std::ranges::equal_range(v, value);

// Counting
std::ranges::count(v, value);
std::ranges::count_if(v, pred);
std::ranges::distance(r);               // O(n) for non-sized

// Predicates
std::ranges::all_of(v, pred);
std::ranges::any_of(v, pred);
std::ranges::none_of(v, pred);
std::ranges::is_sorted(v);
std::ranges::contains(v, value);        // C++23

// Transforming
std::ranges::copy(v, out);
std::ranges::copy_if(v, out, pred);
std::ranges::transform(v, out, fn);
std::ranges::transform(v1, v2, out, fn); // binary transform
std::ranges::fill(v, value);
std::ranges::generate(v, gen);
std::ranges::replace(v, old_val, new_val);
std::ranges::replace_if(v, pred, new_val);
std::ranges::reverse(v);
std::ranges::rotate(v, v.begin()+n);

// Removing (erase-remove idiom)
auto [first, last] = std::ranges::remove(v, value);
v.erase(first, last);
auto [f, l] = std::ranges::remove_if(v, pred);
v.erase(f, l);
// C++20: std::erase / std::erase_if (simpler)
std::erase(v, value);
std::erase_if(v, pred);

// Set operations (sorted ranges)
std::ranges::merge(a, b, out);
std::ranges::set_union(a, b, out);
std::ranges::set_intersection(a, b, out);
std::ranges::set_difference(a, b, out);
std::ranges::inplace_merge(v, v.begin()+n);

// Heap
std::ranges::make_heap(v);
std::ranges::push_heap(v);
std::ranges::pop_heap(v);
std::ranges::sort_heap(v);

// Min/max
std::ranges::min(v);
std::ranges::max(v);
std::ranges::minmax(v);               // returns {min, max}
std::ranges::min_element(v);         // returns iterator
std::ranges::max_element(v);
std::ranges::clamp(val, lo, hi);

// Transformation
views::transform(fn)         // map each element
views::filter(pred)          // keep matching elements
views::reverse               // iterate backwards

// Slicing
views::take(n)               // first n elements
views::drop(n)               // skip first n
views::take_while(pred)      // take while pred holds
views::drop_while(pred)      // skip while pred holds
views::slice(from, to)       // [from, to) (via drop|take)

// Indexing
views::enumerate(r)          // (index, value) pairs — C++23
views::keys                  // first of pair/tuple
views::values                // second of pair/tuple
views::elements<N>           // Nth element of tuple

// Generating
views::iota(0, 10)           // 0,1,...,9
views::iota(0)               // 0,1,2,... (infinite)
views::repeat(val, n)        // n copies of val — C++23
views::empty<T>              // empty range of type T
views::single(val)           // range of one element

// Combining
views::zip(a, b, ...)        // C++23: iterate together
views::zip_transform(fn, a, b) // C++23: zip + transform
views::concat(a, b)          // C++26: concatenate ranges
views::join                  // flatten range of ranges
views::join_with(delim)      // C++23: flatten with delimiter

// Chunking
views::chunk(n)              // C++23: non-overlapping chunks
views::slide(n)              // C++23: sliding window
views::stride(n)             // C++23: every nth element
views::adjacent<N>           // C++23: N-tuples of consecutive

// Splitting
views::split(delim)          // split on delimiter
views::lazy_split(delim)     // lazy split (no caching)

// String
views::as_rvalue             // C++23: move elements
views::as_const              // C++23: read-only view
views::counted(it, n)        // n elements starting at it

// C++23
auto v = range | std::ranges::to<std::vector>();
auto s = range | std::ranges::to<std::set>();

// C++20 — manual
std::vector<int> v(r.begin(), r.end());
std::ranges::copy(r, std::back_inserter(v));

// Sort/find/count by member without a comparator
std::ranges::sort(people, {}, &Person::age);
std::ranges::find(people, "Alice", &Person::name);
std::ranges::count_if(v, [](int n){ return n > 0; });  // no projection needed
std::ranges::min(people, {}, &Person::salary);