std::ranges

<ranges> вводит range — concept, описывающий что угодно, у чего есть begin() и end() (сам std::vector, например, автоматически ему удовлетворяет). Поверх range строятся views — ленивые, некопирующие адаптеры, каждый из которых оборачивает исходный range дополнительной логикой (фильтрация, преобразование, взятие первых N элементов) и сами являются range. Views компонуются через оператор |, как конвейер в Unix-shell.The <ranges> header introduces range — a concept describing anything that has a begin() and an end() (a plain std::vector, for instance, automatically satisfies it). Views are built on top of range — lazy, non-owning adaptors, each wrapping the underlying range with extra logic (filtering, transforming, taking the first N elements) while themselves being a range. Views compose with the | operator, like a pipe in a Unix shell.

auto result = data
    | std::views::filter([](int x) { return x % 2 == 0; })
    | std::views::transform([](int x) { return x * x; });
// ничего не вычислено на этой строке — result хранит только цепочку адаптеров// nothing has been computed on this line — result only holds the chain of adaptors

for (int v : result) { // вычисление происходит здесь, элемент за элементом// evaluation happens here, element by element
    // v — квадрат очередного чётного числа из data// v — the square of the next even number from data
}

До ranges цепочка операций над последовательностью упиралась в компромисс между читаемостью и лишними затратами:Before ranges, a chain of operations over a sequence forced a trade-off between readability and wasted overhead:

Оператор | для views — это перегруженный operator|, который принимает range слева и объект-адаптер справа и возвращает новый view, оборачивающий исходный range. Каждый шаг цепочки — это отдельный тип (например, std::ranges::filter_view<Base, Pred>), а не результат вычисления — сама цепочка описывает план вычисления, который разворачивается только при итерации.The | operator for views is an overloaded operator| that takes a range on the left and an adaptor object on the right, and returns a new view wrapping the underlying range. Each step in the chain is a distinct type (for instance, std::ranges::filter_view<Base, Pred>), not a computed result — the chain itself describes a computation plan that only unfolds during iteration.

// базовые views: коротко о каждом// basic views: a quick rundown of each
std::vector<int> data = {1, 2, 3, 4, 5, 6};

auto evens   = data | std::views::filter([](int x){ return x % 2 == 0; });
// evens: только чётные — 2, 4, 6// evens: only the even ones — 2, 4, 6

auto squares = data | std::views::transform([](int x){ return x * x; });
// squares: 1, 4, 9, 16, 25, 36// squares: 1, 4, 9, 16, 25, 36

auto firstThree = data | std::views::take(3);   // 1, 2, 3// 1, 2, 3
auto skipTwo    = data | std::views::drop(2);   // 3, 4, 5, 6// 3, 4, 5, 6
auto backwards  = data | std::views::reverse;   // 6, 5, 4, 3, 2, 1// 6, 5, 4, 3, 2, 1

auto naturals = std::views::iota(1);        // 1, 2, 3, 4, ... — бесконечная последовательность// 1, 2, 3, 4, ... — an infinite sequence
auto firstFive = naturals | std::views::take(5);  // безопасно — take останавливает итерацию// safe — take stops the iteration

views::iota без второго аргумента сама по себе бесконечна — итерация по ней напрямую (например, в range-based for без take) никогда не завершится. Именно поэтому iota почти всегда используется в связке с take или с явной верхней границей вторым аргументом (views::iota(1, 100)) — сама по себе она лишь описывает правило генерации следующего значения, не количество элементов.views::iota without a second argument is infinite by itself — iterating over it directly (say, in a range-based for with no take) never terminates. That's exactly why iota is almost always paired with take or given an explicit upper bound as a second argument (views::iota(1, 100)) — on its own it only describes the rule for generating the next value, not how many elements there are.

// три view подряд одной цепочкой — порядок вычисления построчно// three views chained together — the evaluation order, step by step
std::vector<int> nums = {1, 2, 3, 4, 5, 6, 7, 8};

auto pipeline = nums
    | std::views::filter([](int x) { return x % 2 == 0; })   // шаг 1: пропустить только чётные// step 1: let only even numbers through
    | std::views::transform([](int x) { return x * 10; })   // шаг 2: умножить каждое прошедшее фильтр значение на 10// step 2: multiply each value that passed the filter by 10
    | std::views::take(2);                                        // шаг 3: взять только первые два результата// step 3: take only the first two results

for (int v : pipeline) { /* v = 20, затем v = 40 *//* v = 20, then v = 40 */ }
// вычисление идёт не "сначала весь filter, потом весь transform", а поэлементно:// evaluation isn't "run all of filter, then all of transform" — it's element by element:
// take запрашивает у transform первый элемент, transform запрашивает у filter первый// take asks transform for the first element, transform asks filter for the first
// подходящий элемент у nums (2), transform умножает его на 10 (20) — и take его отдаёт;// matching element from nums (2), transform multiplies it by 10 (20) — take yields it;
// цикл нигде не проходит по nums целиком раньше времени// the loop never walks the whole of nums ahead of time

• cppreference — Range library
• WG21 P0896 — The One Ranges Proposal