std::ranges::*

Пространство имён std::ranges содержит переписанные версии алгоритмов из <algorithm> — sort, find, copy, transform и десятки других — принимающие range (см. ranges — основы) одним аргументом вместо пары итераторов begin()/end(). Дополнительно эти версии — constrained algorithms: их шаблонные параметры ограничены concepts, и большинство поддерживает необязательный параметр-проекцию.The std::ranges namespace contains rewritten versions of the algorithms from <algorithm> — sort, find, copy, transform, and dozens more — taking a range (see ranges — basics) as a single argument instead of a pair of begin()/end() iterators. On top of that, these versions are constrained algorithms: their template parameters are constrained by concepts, and most support an optional projection parameter.

std::sort(people.begin(), people.end(),
    [](const Person& a, const Person& b) {
        return a.age < b.age;
    });
// имя контейнера повторяется дважды — a.begin()/b.end() компилируется и есть UB// the container name repeats twice — a.begin()/b.end() compiles and is UB

std::ranges::sort(people, {}, &Person::age);
// {} — компаратор по умолчанию (<), &Person::age — проекция// {} — the default comparator (<), &Person::age — the projection

Constrained algorithm — обычный шаблон функции, чьи параметры типов ограничены через concepts (см. стандартную библиотеку concepts) в самой сигнатуре, а не через enable_if где-то внутри. Проекция — необязательный третий (после диапазона и компаратора) параметр-функция, применяемый к каждому элементу перед тем, как его передать компаратору или предикату — сравнивается не сам элемент, а результат применения проекции к нему.A constrained algorithm is an ordinary function template whose type parameters are constrained via concepts (see standard library concepts) directly in the signature, rather than through an enable_if buried somewhere inside. A projection is an optional third parameter (after the range and the comparator) — a function applied to each element before it's handed to the comparator or predicate — what gets compared isn't the element itself, but the result of applying the projection to it.

// упрощённая сигнатура std::ranges::sort — не дословный текст стандарта// a simplified signature of std::ranges::sort — not the standard's literal wording
template <std::ranges::random_access_range R,
          class Comp = std::ranges::less,
          class Proj = std::identity>
requires std::sortable<std::ranges::iterator_t<R>, Comp, Proj>
void sort(R&& r, Comp comp = {}, Proj proj = {});

// пример: сортировка структур по полю без ручной лямбды// example: sorting structs by a field with no hand-written lambda
struct Person { std::string name; int age; };
std::vector<Person> people = /* ... *//* ... */;

std::ranges::sort(people, {}, &Person::age);
// {} — дефолтный std::ranges::less как компаратор// {} — the default std::ranges::less as the comparator
// &Person::age — проекция: сравниваются person.age, а не сам Person// &Person::age — the projection: person.age gets compared, not the Person itself

auto it = std::ranges::find(people, 30, &Person::age);
// найти первого человека с age == 30 — без лямбды-предиката// find the first person with age == 30 — no predicate lambda needed

Именно поэтому проекция стоит третьим параметром, после компаратора — если компаратор не нужен, на его месте обязателен {}, чтобы указать проекцию четвёртым... точнее, третьим позиционным аргументом после диапазона.This is exactly why the projection comes third, after the comparator — if no comparator is needed, a {} must occupy its place so the projection can be passed as the next positional argument after the range.

Проекции работают не только в sort/find — std::ranges::find_if принимает проекцию тем же третьим параметром, применяя предикат к результату проекции, а не к самому элементу. Отдельно constrained algorithms решают идиому "удалить дубликаты из vector" чище классической: std::ranges::unique возвращает subrange, описывающий "хвост" с дубликатами, готовый к передаче прямо в erase — без отдельного вызова std::distance или ручной арифметики итераторов.Projections aren't limited to sort/find — std::ranges::find_if accepts a projection in the same third slot, applying the predicate to the projection's result rather than to the element itself. Separately, constrained algorithms handle the "remove duplicates from a vector" idiom more cleanly than the classic approach: std::ranges::unique returns a subrange describing the duplicate "tail," ready to be handed straight to erase — with no separate std::distance call or manual iterator arithmetic.

struct Task { std::string name; bool done; };
std::vector<Task> tasks = /* ... *//* ... */;

auto it = std::ranges::find_if(tasks, [](bool done) { return !done; }, &Task::done);
// предикат применяется к task.done (результату проекции), а не к Task целиком// the predicate is applied to task.done (the projection's result), not to the whole Task

std::vector<int> v = {1, 1, 2, 2, 2, 3, 1, 1};
auto [first, last] = std::ranges::unique(v);   // сдвигает уникальные элементы влево, возвращает subrange дубликатов// shifts unique elements left, returns a subrange of the duplicates
v.erase(first, last);                       // v == {1, 2, 3, 1}: подряд идущие дубликаты убраны// v == {1, 2, 3, 1}: consecutive duplicates removed

• cppreference — Constrained algorithms
• WG21 P0896 — The One Ranges Proposal