Библиотека ranges (начиная с C++20)

Библиотека ranges — это расширение и обобщение библиотек алгоритмов и итераторов, которое делает их более мощными благодаря возможности комбинировать их и меньшей подверженности ошибкам.

Библиотека создаёт и обрабатывает представления диапазонов — лёгкие объекты, которые косвенно представляют итерируемые последовательности (диапазоны). Диапазоны представляют собой абстракцию над

• [begin, end) – парами итераторов, например диапазонами, полученными посредством неявного преобразования контейнеров. Для всех алгоритмов, принимающих пары итераторов, теперь существуют перегрузки, принимающие диапазоны (например, ranges::sort)
• begin + [0, size) – последовательностями с заданным количеством элементов, например диапазоном, возвращаемым views::counted
• [begin, предикатом) – последовательностями с условием завершения, например диапазоном, возвращаемым views::take_while
• [begin, ..) – неограниченными последовательностями, например диапазоном, возвращаемым views::iota

Библиотека ranges включает алгоритмы для диапазонов, которые применяются к диапазонам сразу, и адаптеры диапазонов, которые применяются к представлениям лениво. Адаптеры можно объединять в конвейеры, чтобы их действия выполнялись при обходе представления.

namespace std {
    namespace views = ranges::views;
}

Псевдоним пространства имён std::views предоставлен для краткой записи std::ranges::views.

Фабрики диапазонов

Адаптеры диапазонов

Генераторы диапазонов (с C++23)

Вспомогательные элементы

Объекты-адаптеры диапазонов

См. RangeAdaptorObject (RAO).

Объекты-замыкания адаптера диапазона

См. RangeAdaptorClosureObject (RACO).

Объекты точек настройки

См. объект точки настройки (CPO).

Оболочка с возможностью присваивания

Некоторые адаптеры диапазонов оборачивают свои элементы или функциональные объекты с помощью copyable-box(до C++23)movable-box(с C++23). Оболочка добавляет обёрнутому объекту возможность присваивания, если это необходимо.

Нераспространяющийся кэш

Некоторые адаптеры диапазонов описываются через шаблон класса non-propagating-cache, предназначенный только для описания и почти аналогичный std::optional<T> (различия см. в описании).

Условный тип const

template< bool Const, class T >
using /*maybe-const*/ = std::conditional_t<Const, const T, T>;

Шаблон псевдонима /*maybe-const*/ — это сокращённая запись, используемая для условного добавления квалификатора const к типу T.

Вспомогательные шаблоны типов целочисленного вида

template< /*is-integer-like*/ T >
using /*make-signed-like-t*/<T> = /* see description */;

template< /*is-integer-like*/ T >
using /*make-unsigned-like-t*/<T> = /* see description */;

template< /*is-integer-like*/ T >
/*make-unsigned-like-t*/<T> /*to-unsigned-like*/( T t )
{
    return static_cast</*make-unsigned-like-t*/<T>>(t);
}

• Если T является целочисленным типом, /*make-signed-like-t*/<T> — это std::make_signed_t<T>.
• В противном случае /*make-signed-like-t*/<T> — это соответствующий знаковый тип целочисленного вида с неуказанным именем и той же шириной, что и T.

• Если T является целочисленным типом, /*make-unsigned-like-t*/<T> — это std::make_unsigned_t<T>.
• В противном случае /*make-signed-like-t*/<T> — это соответствующий беззнаковый тип целочисленного вида с неуказанным именем и той же шириной, что и T.

Вспомогательные средства для объектов точек настройки

template< ranges::input_range R >
constexpr auto& /*possibly-const-range*/(R& r) noexcept
{
    if constexpr (ranges::input_range<const R>)
        return const_cast<const R&>(r);
    else
        return r;
}

template< class T >
constexpr auto /*as-const-pointer*/( const T* p ) noexcept
{
    return p;
}

Некоторые объекты точек настройки доступа к диапазонам описываются через эти шаблоны функций, предназначенные только для описания.

Вспомогательные средства для адаптеров диапазонов

template< class F, class Tuple >
constexpr auto /*tuple-transform*/( F&& f, Tuple&& tuple )
{
    return std::apply([&]<class... Ts>(Ts&&... args)
    {
        return std::tuple<std::invoke_result_t<F&, Ts>...>
            (std::invoke(f, std::forward<Ts>(args))...);
    }, std::forward<Tuple>(tuple));
}

template< class F, class Tuple >
constexpr void /*tuple-for-each*/( F&& f, Tuple&& tuple )
{
    std::apply([&]<class... Ts>(Ts&&... args)
    {
        (static_cast<void>(std::invoke(f, std::forward<Ts>(args))), ...);
    }, std::forward<Tuple>(tuple));
}

template< class T >
constexpr T& /*as-lvalue*/( T&& t )
{
    return static_cast<T&>(t);
}

Некоторые адаптеры диапазонов описываются через эти шаблоны функций, предназначенные только для описания.

Вспомогательные концепты

Следующие концепты, используемые только для описания, применяются для нескольких типов, но не являются частью интерфейса стандартной библиотеки.

template< class R >
concept /*simple-view*/ =
    ranges::view<R> && ranges::range<const R> &&
    std::same_as<ranges::iterator_t<R>, ranges::iterator_t<const R>> &&
    std::same_as<ranges::sentinel_t<R>, ranges::sentinel_t<const R>>;

template< class I >
concept /*has-arrow*/ =
    ranges::input_iterator<I> &&
    (std::is_pointer_v<I> || requires(const I i) { i.operator->(); });

template< class T, class U >
concept /*different-from*/ =
    !std::same_as<std::remove_cvref_t<T>, std::remove_cvref_t<U>>;

template< class R >
concept /*range-with-movable-references*/ =
    ranges::input_range<R> &&
    std::move_constructible<ranges::range_reference_t<R>> &&
    std::move_constructible<ranges::range_rvalue_reference_t<R>>;

template< bool C, class... Views >
concept /*all-random-access*/ =
    (ranges::random_access_range
         <std::conditional_t<C, const Views, Views>> && ...);

template< bool C, class... Views >
concept /*all-bidirectional*/ =
    (ranges::bidirectional_range
         <std::conditional_t<C, const Views, Views>> && ...);

template< bool C, class... Views >
concept /*all-forward*/ =
    (ranges::forward_range
         <std::conditional_t<C, const Views, Views>> && ...);

Примечания

Пример

#include <iostream>
#include <ranges>

int main()
{
    auto const ints = {0, 1, 2, 3, 4, 5};
    auto even = [](int i) { return 0 == i % 2; };
    auto square = [](int i) { return i * i; };
    
    // the "pipe" syntax of composing the views:
    for (int i : ints | std::views::filter(even) | std::views::transform(square))
        std::cout << i << ' ';
    
    std::cout << '\n';
    
    // a traditional "functional" composing syntax:
    for (int i : std::views::transform(std::views::filter(ints, even), square))
        std::cout << i << ' ';
}

0 4 16
0 4 16

Отчёты об исправлении дефектов

Следующие отчёты об исправлении дефектов, меняющие поведение, были применены задним числом к ранее опубликованным стандартам C++.

См. также

• Библиотека итераторов
• Алгоритмы с ограничениями