Библиотека диапазонов (C++20)

Библиотека диапазонов является расширением и обобщением библиотек алгоритмов и итераторов, делающих их более мощными благодаря возможности композиции и снижению вероятности ошибок.

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

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

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

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

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

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

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

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

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

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

См. RangeAdaptorObject (РАО).

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

См. RangeAdaptorClosureObject (РАКО).

Объекты точек кастомизации

См. Объект точки кастомизации (ОТПК).

Обёртка с присваиванием

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

Кэш без распространения

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

Помощники объектов точек кастомизации

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

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

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

Помощники адаптеров диапазонов

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

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

Примечания

Пример

#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++.

См. также

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