Заголовочный файл стандартной библиотеки <ranges> (C++20)
Материал из cppreference.com
Этот заголовочный файл это часть ranges библиотеки.
[править]Псевдонимы пространств имен
namespace std { namespace views = ranges::views; | ||
Псевдоним пространства имен std::views предоставляется как сокращение для std::ranges::views.
Includes | |
(C++20) | Поддержка оператора трёхстороннего сравнения |
(C++11) | Шаблонный класс std::initializer_list |
| Диапазонные итераторы | |
Concepts | |
Range concepts | |
Определены в пространстве имён std::ranges | |
(C++20) | указывает, что тип является диапазоном, то есть предоставляет итератор begin и ограничитель end(концепт) |
(C++20) | указывает, что тип является range, и итераторы, полученные из его выражения, могут быть безопасно возвращены без опасности зависания (концепт) |
(C++20) | указывает, что диапазон узнаёт свой размер за константное время (концепт) |
(C++20) | указывает, что диапазон является представлением, то есть имеет постоянное время копирования/перемещения/присваивания (концепт) |
(C++20) | указывает диапазон, тип итератора которого соответствует input_iterator(концепт) |
(C++20) | указывает диапазон, тип итератора которого соответствует output_iterator(концепт) |
(C++20) | указывает диапазон, тип итератора которого соответствует forward_iterator(концепт) |
(C++20) | указывает диапазон, тип итератора которого соответствует bidirectional_iterator(концепт) |
(C++20) | указывает диапазон, тип итератора которого соответствует random_access_iterator(концепт) |
(C++20) | указывает диапазон, тип итератора которого соответствует contiguous_iterator(концепт) |
(C++20) | указывает, что диапазон имеет идентичные типы итератора и ограничителя (концепт) |
(C++20) | определяет требования к range для безопасного преобразования в view(концепт) |
(C++23) | определяет диапазон доступных только для чтения элементов (концепт) |
Functions | |
Range conversions | |
Определены в пространстве имён std::ranges | |
(C++23) | создаёт непросматриваемый объект из входного диапазона (шаблон функции) |
Classes | |
Range primitives | |
Определены в пространстве имён std::ranges | |
(C++20)(C++23)(C++20)(C++23)(C++20)(C++20)(C++20)(C++20)(C++23)(C++20)(C++20) | получает ассоциированные типы диапазона (псевдоним шаблона) |
Views | |
Определены в пространстве имён std::ranges | |
(C++20) | шаблон вспомогательного класса для определения view, используя любопытно повторяющийся образец шаблон(шаблон класса) |
(C++20) | объединяет пару итератор-ограничитель в view(шаблон класса) |
Dangling iterator handling | |
Определены в пространстве имён std::ranges | |
(C++20) | тип заполнителя, указывающий, что итератор или поддиапазон не должны быть возвращены, так как они будут висячими (класс) |
получает тип итератора или тип поддиапазона из borrowed_range(псевдоним шаблона) | |
Range adaptor objects utility | |
Определены в пространстве имён std::ranges | |
| вспомогательный шаблон базового класса для определения объекта замыкания адаптера диапазона (шаблон класса) | |
Factories | |
Определены в пространстве имён std::ranges | |
пустой view без элементов (шаблон класса)(шаблонная переменная) | |
view, который содержит единственный элемент указанного значения (шаблон класса)(объект точки настройки) | |
(C++20) | view, состоящий из последовательности, сгенерированной путём многократного увеличения начального значения (шаблон класса)(объект точки настройки) |
view, состоящий из элементов, полученных последовательным применением operator>> к соответствующему входному потоку (шаблон класса)(объект точки настройки) | |
view, состоящее из последовательности сгенерированной путём повторного создания одного и того же значения (шаблон класса)(объект точки настройки) | |
view, состоящее из кортежей результатов, вычисленных с помощью n-арного декартова произведения адаптированных представлений (шаблон класса)(объект точки настройки) | |
Adaptors | |
Определены в пространстве имён std::ranges | |
(C++20) | view, который включает все элементы range(псевдоним шаблона)(объект адаптера диапазона) |
(C++20) | view из элементов некоторого другого range(шаблон класса) |
(C++20) | view с уникальным владельцем некоторого range(шаблон класса) |
view, который состоит из элементов range, который соответствует предикату (шаблон класса)(объект адаптера диапазона) | |
view последовательности, которая применяет функцию преобразования к каждому элементу (шаблон класса)(объект адаптера диапазона) | |
(C++20) | view, состоящий из первых N элементов другого view(шаблон класса)(объект адаптера диапазона) |
view, состоящий из начальных элементов другого view, до первого элемента, для которого предикат не вернёт false(шаблон класса)(объект адаптера диапазона) | |
(C++20) | view, состоящий из элементов другого view, пропуская первые N элементов (шаблон класса)(объект адаптера диапазона) |
view, состоящий из элементов другого view, пропуская начальную подпоследовательность элементов до первого элемента, для которого предикат вернёт false(шаблон класса)(объект адаптера диапазона) | |
(C++20) | view, состоящий из последовательности, полученной уплотнением view, состоящего из range(шаблон класса)(объект адаптера диапазона) |
view по поддиапазонам, полученным в результате разделения другого view с использованием разделителя (шаблон класса)(объект адаптера диапазона) | |
view по поддиапазонам, полученным в результате разделения другого view с использованием разделителя (шаблон класса)(объект адаптера диапазона) | |
(C++20) | создаёт поддиапазон из итератора и счётчика (объект точки настройки) |
преобразует view в common_range(шаблон класса)(объект адаптера диапазона) | |
view, который перебирает элементы другого двунаправленного представления в обратном порядке (шаблон класса)(объект адаптера диапазона) | |
преобразует view в constant_range(шаблон класса)(объект адаптера диапазона) | |
view последовательность, которая приводит каждый элемент к rvalue (шаблон класса)(объект адаптера диапазона) | |
принимает view, состоящий из tuple-like значений, и числа N, и создаёт view из Nго элемента каждого кортежа (шаблон класса)(объект адаптера диапазона) | |
(C++20) | принимает view, состоящий из парных значений, и создаёт view первых элементов каждой пары (шаблон класса)(объект адаптера диапазона) |
принимает view, состоящий из парных значений, и создаёт view из вторых элементов каждой пары (шаблон класса)(объект адаптера диапазона) | |
view, который отображает каждый элемент адаптированной последовательности в кортеж как позиции элемента, так и его значения (шаблон класса)(объект адаптера диапазона) | |
(C++23) | view, состоящий из кортежей ссылок на соответствующие элементы адаптированных представлений (шаблон класса)(объект точки настройки) |
view, состоящий из кортежей результатов применения функции преобразования к соответствующим элементам адаптированных представлений (шаблон класса)(объект точки настройки) | |
view, состоящий из кортежей ссылок на соседние элементы адаптированного представления (шаблон класса)(объект адаптера диапазона) | |
view, состоящий из кортежей результатов применения функции преобразования к смежным элементам адаптированного представления (шаблон класса)(объект адаптера диапазона) | |
view, состоящее из последовательности, полученной путём выравнивания представления диапазонов, с разделителем между элементами (шаблон класса)(объект адаптера диапазона) | |
view, состоящее из элементов другого view, перемещаюемся по N элементам за раз (шаблон класса)(объект адаптера диапазона) | |
view, элемент Mый которого является view над Mый через (M + N - 1)ый элементы другого view(шаблон класса)(объект адаптера диапазона) | |
диапазон нескольких view, которые представляют собой неперекрывающиеся последовательные фрагменты элементов другого view размера N(шаблон класса)(объект адаптера диапазона) | |
разбивает view на поддиапазоны между каждой парой смежных элементов, для которых данный предикат возвращает false(шаблон класса)(объект адаптера диапазона) | |
Customization point objects | |
Range access | |
Определены в пространстве имён std::ranges | |
(C++20) | возвращает итератор на начало диапазона (объект точки настройки) |
(C++20) | возвращает ограничитель, указывающий на конец диапазона (объект точки настройки) |
(C++20) | возвращает итератор на начало диапазона только для чтения (объект точки настройки) |
(C++20) | возвращает ограничитель, указывающий на конец диапазона, доступного только для чтения (объект точки настройки) |
(C++20) | возвращает обратный итератор на диапазон (объект точки настройки) |
(C++20) | возвращает обратный конечный итератор диапазона (объект точки настройки) |
(C++20) | возвращает обратный итератор на диапазон только для чтения (объект точки настройки) |
(C++20) | возвращает обратный конечный итератор на диапазон только для чтения (объект точки настройки) |
(C++20) | возвращает целое число, равное размеру диапазона (объект точки настройки) |
(C++20) | возвращает целое число со знаком, равное размеру диапазона (объект точки настройки) |
(C++20) | проверяет, пуст ли диапазон (объект точки настройки) |
(C++20) | получает указатель на начало непрерывного диапазона (объект точки настройки) |
(C++20) | получает указатель на начало непрерывного диапазона, доступного только для чтения (объект точки настройки) |
Enumerations | |
Определены в пространстве имён std::ranges | |
(C++20) | определяет, моделирует ли std::ranges::subrangestd::ranges::sized_range (перечисление) |
Helpers | |
| получает количество компонентов std::ranges::subrange (специализация шаблона класса) | |
| получает тип итератора или ограничителя для std::ranges::subrange (специализация шаблона класса) | |
(C++20) | получает итератор или ограничитель из std::ranges::subrange (шаблон функции) |
(C++20) | определяет диапазон, итератор которого удовлетворяет forward_iterator(концепт) |
[править]Краткое содержание
#include <compare>#include <initializer_list>#include <iterator> namespace std::ranges{inlinenamespace/* unspecified */{// range accessinlineconstexpr/* unspecified */ begin =/* unspecified */;// freestandinginlineconstexpr/* unspecified */ end =/* unspecified */;// freestandinginlineconstexpr/* unspecified */ cbegin =/* unspecified */;// freestandinginlineconstexpr/* unspecified */ cend =/* unspecified */;// freestandinginlineconstexpr/* unspecified */ rbegin =/* unspecified */;// freestandinginlineconstexpr/* unspecified */ rend =/* unspecified */;// freestandinginlineconstexpr/* unspecified */ crbegin =/* unspecified */;// freestandinginlineconstexpr/* unspecified */ crend =/* unspecified */;// freestanding inlineconstexpr/* unspecified */ size =/* unspecified */;// freestandinginlineconstexpr/* unspecified */ ssize =/* unspecified */;// freestandinginlineconstexpr/* unspecified */ empty =/* unspecified */;// freestandinginlineconstexpr/* unspecified */ data =/* unspecified */;// freestandinginlineconstexpr/* unspecified */ cdata =/* unspecified */;// freestanding} // rangestemplate<class T> concept range =/* see description */;// freestanding template<class T>inlineconstexprbool enable_borrowed_range =false;// freestanding template<class T> concept borrowed_range =/* see description */;// freestanding template<class T>using iterator_t = decltype(ranges::begin(declval<T&>()));// freestandingtemplate<range R>using sentinel_t = decltype(ranges::end(declval<R&>()));// freestandingtemplate<range R>using const_iterator_t = const_iterator<iterator_t<R>>;// freestandingtemplate<range R>using range_difference_t = iter_difference_t<iterator_t<R>>;// freestandingtemplate<sized_range R>using range_size_t = decltype(ranges::size(declval<R&>()));// freestandingtemplate<range R>using range_value_t = iter_value_t<iterator_t<R>>;// freestandingtemplate<range R>using range_reference_t = iter_reference_t<iterator_t<R>>;// freestandingtemplate<range R>using range_const_reference_t = iter_const_reference_t<iterator_t<R>>;// freestandingtemplate<range R>using range_rvalue_reference_t = iter_rvalue_reference_t<iterator_t<R>>;// freestandingtemplate<range R>using range_common_reference_t = iter_common_reference_t<iterator_t<R>>;// freestanding // sized rangestemplate<class>inlineconstexprbool disable_sized_range =false;// freestanding template<class T> concept sized_range =/* see description */;// freestanding // viewstemplate<class T>inlineconstexprbool enable_view =/* see description */;// freestanding struct view_base {};// freestanding template<class T> concept view =/* see description */;// freestanding // other range refinementstemplate<class R, class T> concept output_range =/* see description */;// freestanding template<class T> concept input_range =/* see description */;// freestanding template<class T> concept forward_range =/* see description */;// freestanding template<class T> concept bidirectional_range =/* see description */;// freestanding template<class T> concept random_access_range =/* see description */;// freestanding template<class T> concept contiguous_range =/* see description */;// freestanding template<class T> concept common_range =/* see description */;// freestanding template<class T> concept viewable_range =/* see description */;// freestanding template<class T> concept constant_range =/* see description */;// freestanding // class template view_interfacetemplate<class D> requires is_class_v<D>&& same_as<D, remove_cv_t<D>>class view_interface;// freestanding // sub-rangesenumclass subrange_kind :bool{ unsized, sized };// freestanding template<input_or_output_iterator I, sentinel_for<I> S = I, subrange_kind K =/* see description */> requires (K == subrange_kind::sized||!sized_sentinel_for<S, I>)class subrange;// freestanding template<class I, class S, subrange_kind K>inlineconstexprbool enable_borrowed_range<subrange<I, S, K>>=true;// freestanding template<size_t N, class I, class S, subrange_kind K> requires ((N ==0&& copyable<I>)|| N ==1)constexprauto get(const subrange<I, S, K>& r);// freestanding template<size_t N, class I, class S, subrange_kind K> requires (N <2)constexprauto get(subrange<I, S, K>&& r);// freestanding} namespace std {usingranges::get;// freestanding} namespace std::ranges{// dangling iterator handlingstruct dangling;// freestanding // class template elements_oftemplate<range R, class Allocator = allocator<byte>>struct elements_of; template<range R>using borrowed_iterator_t =/* see description */;// freestanding template<range R>using borrowed_subrange_t =/* see description */;// freestanding // range conversionstemplate<class C, input_range R, class... Args> requires (!view<C>)constexpr C to(R&& r, Args&&... args);// freestandingtemplate<template<class...>class C, input_range R, class... Args>constexprauto to(R&& r, Args&&... args);// freestandingtemplate<class C, class... Args> requires (!view<C>)constexprauto to(Args&&... args);// freestandingtemplate<template<class...>class C, class... Args>constexprauto to(Args&&... args);// freestanding // empty viewtemplate<class T> requires is_object_v<T>class empty_view;// freestanding template<class T>inlineconstexprbool enable_borrowed_range<empty_view<T>>=true;// freestanding namespace views {template<class T>inlineconstexpr empty_view<T> empty{};// freestanding} // single viewtemplate<move_constructible T> requires is_object_v<T>class single_view;// freestanding namespace views {inlineconstexpr/* unspecified */ single =/* unspecified */;}// freestanding template<bool Const, class T>using __maybe_const = conditional_t<Const, const T, T>;// exposition only // iota viewtemplate<weakly_incrementable W, semiregular Bound = unreachable_sentinel_t> requires __weakly_equality_comparable_with<W, Bound>&& copyable<W>class iota_view;// freestanding template<class W, class Bound>inlineconstexprbool enable_borrowed_range<iota_view<W, Bound>>=true;// freestanding namespace views {inlineconstexpr/* unspecified */ iota =/* unspecified */;}// freestanding // repeat viewtemplate<move_constructible W, semiregular Bound = unreachable_sentinel_t> requires (is_object_v<W>&& same_as<W, remove_cv_t<W>>&&(__is_integer_like<Bound>|| same_as<Bound, unreachable_sentinel_t>))class repeat_view; namespace views {inlineconstexpr/* unspecified */ repeat =/* unspecified */;} // istream viewtemplate<movable Val, class CharT, class Traits = char_traits<CharT>> requires /* see description */class basic_istream_view;template<class Val>using istream_view = basic_istream_view<Val, char>;template<class Val>using wistream_view = basic_istream_view<Val, wchar_t>; namespace views {template<class T>inlineconstexpr/* unspecified */ istream =/* unspecified */;} // range adaptor objectstemplate<class D> requires is_class_v<D>&& same_as<D, remove_cv_t<D>>class range_adaptor_closure {};// freestanding // all viewnamespace views {inlineconstexpr/* unspecified */ all =/* unspecified */;// freestanding template<viewable_range R>using all_t = decltype(all(declval<R>()));// freestanding} // ref viewtemplate<range R> requires is_object_v<R>class ref_view;// freestanding template<class T>inlineconstexprbool enable_borrowed_range<ref_view<T>>=true;// freestanding // owning viewtemplate<range R> requires /* see description */class owning_view;// freestanding template<class T>inlineconstexprbool enable_borrowed_range<owning_view<T>>=// freestanding enable_borrowed_range<T>; // as rvalue viewtemplate<view V> requires input_range<V>class as_rvalue_view;// freestanding template<class T>inlineconstexprbool enable_borrowed_range<as_rvalue_view<T>>=// freestanding enable_borrowed_range<T>; namespace views {inlineconstexpr/* unspecified */ as_rvalue =/* unspecified */;}// freestanding // filter viewtemplate<input_range V, indirect_unary_predicate<iterator_t<V>> Pred> requires view<V>&& is_object_v<Pred>class filter_view;// freestanding namespace views {inlineconstexpr/* unspecified */ filter =/* unspecified */;}// freestanding // transform viewtemplate<input_range V, move_constructible F> requires view<V>&& is_object_v<F>&& regular_invocable<F&, range_reference_t<V>>&& __can_reference<invoke_result_t<F&, range_reference_t<V>>>class transform_view;// freestanding namespace views {inlineconstexpr/* unspecified */ transform =/* unspecified */;}// freestanding // take viewtemplate<view>class take_view;// freestanding template<class T>inlineconstexprbool enable_borrowed_range<take_view<T>>=// freestanding enable_borrowed_range<T>; namespace views {inlineconstexpr/* unspecified */ take =/* unspecified */;}// freestanding // take while viewtemplate<view V, class Pred> requires input_range<V>&& is_object_v<Pred>&& indirect_unary_predicate<const Pred, iterator_t<V>>class take_while_view;// freestanding namespace views {inlineconstexpr/* unspecified */ take_while =/* unspecified */;}// freestanding // drop viewtemplate<view V>class drop_view;// freestanding template<class T>inlineconstexprbool enable_borrowed_range<drop_view<T>>=// freestanding enable_borrowed_range<T>; namespace views {inlineconstexpr/* unspecified */ drop =/* unspecified */;}// freestanding // drop while viewtemplate<view V, class Pred> requires input_range<V>&& is_object_v<Pred>&& indirect_unary_predicate<const Pred, iterator_t<V>>class drop_while_view;// freestanding template<class T, class Pred>inlineconstexprbool enable_borrowed_range<drop_while_view<T, Pred>>=// freestanding enable_borrowed_range<T>; namespace views {inlineconstexpr/* unspecified */ drop_while =/* unspecified */;}// freestanding // join viewtemplate<input_range V> requires view<V>&& input_range<range_reference_t<V>>class join_view;// freestanding namespace views {inlineconstexpr/* unspecified */ join =/* unspecified */;}// freestanding // join with viewtemplate<class R, class P> concept __compatible_joinable_ranges =/* see description */;// exposition only template<input_range V, forward_range Pattern> requires view<V>&& input_range<range_reference_t<V>>&& view<Pattern>&& __compatible_joinable_ranges<range_reference_t<V>, Pattern>class join_with_view;// freestanding namespace views {inlineconstexpr/* unspecified */ join_with =/* unspecified */;}// freestanding // lazy split viewtemplate<class R> concept __tiny_range =/* see description */;// exposition only template<input_range V, forward_range Pattern> requires view<V>&& view<Pattern>&& indirectly_comparable<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to>&&(forward_range<V>|| __tiny_range<Pattern>)class lazy_split_view;// freestanding // split viewtemplate<forward_range V, forward_range Pattern> requires view<V>&& view<Pattern>&& indirectly_comparable<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to>class split_view;// freestanding namespace views {inlineconstexpr/* unspecified */ lazy_split =/* unspecified */;// freestandinginlineconstexpr/* unspecified */ split =/* unspecified */;// freestanding} // counted viewnamespace views {inlineconstexpr/* unspecified */ counted =/* unspecified */;}// freestanding // common viewtemplate<view V> requires (!common_range<V>&& copyable<iterator_t<V>>)class common_view;// freestanding template<class T>inlineconstexprbool enable_borrowed_range<common_view<T>>=// freestanding enable_borrowed_range<T>; namespace views {inlineconstexpr/* unspecified */ common =/* unspecified */;}// freestanding // reverse viewtemplate<view V> requires bidirectional_range<V>class reverse_view;// freestanding template<class T>inlineconstexprbool enable_borrowed_range<reverse_view<T>>=// freestanding enable_borrowed_range<T>; namespace views {inlineconstexpr/* unspecified */ reverse =/* unspecified */;}// freestanding // as const viewtemplate<input_range R>constexprauto& __possibly_const_range(R& r){// exposition onlyifconstexpr(constant_range<const R>&&!constant_range<R>){returnconst_cast<const R&>(r);}else{return r;}} template<view V> requires input_range<V>class as_const_view;// freestanding template<class T>inlineconstexprbool enable_borrowed_range<as_const_view<T>>=// freestanding enable_borrowed_range<T>; namespace views {inlineconstexpr/* unspecified */ as_const =/* unspecified */;}// freestanding // elements viewtemplate<input_range V, size_t N> requires /* see description */class elements_view;// freestanding template<class T, size_t N>inlineconstexprbool enable_borrowed_range<elements_view<T, N>>=// freestanding enable_borrowed_range<T>; template<class R>using keys_view = elements_view<R, 0>;// freestandingtemplate<class R>using values_view = elements_view<R, 1>;// freestanding namespace views {template<size_t N>inlineconstexpr/* unspecified */ elements =/* unspecified */;// freestandinginlineconstexprauto keys = elements<0>;// freestandinginlineconstexprauto values = elements<1>;// freestanding} template<range V> requires /* see description */class enumerate_view;// freestanding template<class View>inlineconstexprbool enable_borrowed_range<enumerate_view<View>>=// freestanding enable_borrowed_range<View>; namespace views {inlineconstexpr/* unspecified */ enumerate =/* unspecified */;// freestanding} // zip viewtemplate<input_range... Views> requires (view<Views>&& ...)&&(sizeof...(Views)>0)class zip_view;// freestanding template<class... Views>inlineconstexprbool enable_borrowed_range<zip_view<Views...>>=// freestanding(enable_borrowed_range<Views>&& ...); namespace views {inlineconstexpr/* unspecified */ zip =/* unspecified */;}// freestanding // zip transform viewtemplate<move_constructible F, input_range... Views> requires (view<Views>&& ...)&&(sizeof...(Views)>0)&& is_object_v<F>&& regular_invocable<F&, range_reference_t<Views>...>&& __can_reference<invoke_result_t<F&, range_reference_t<Views>...>>class zip_transform_view;// freestanding namespace views {inlineconstexpr/* unspecified */ zip_transform =/* unspecified */;}// freestanding // adjacent viewtemplate<forward_range V, size_t N> requires view<V>&&(N >0)class adjacent_view;// freestanding template<class V, size_t N>inlineconstexprbool enable_borrowed_range<adjacent_view<V, N>>=// freestanding enable_borrowed_range<V>; namespace views {template<size_t N>inlineconstexpr/* unspecified */ adjacent =/* unspecified */;// freestandinginlineconstexprauto pairwise = adjacent<2>;// freestanding} // adjacent transform viewtemplate<forward_range V, move_constructible F, size_t N> requires /* see description */class adjacent_transform_view;// freestanding namespace views {template<size_t N>inlineconstexpr/* unspecified */ adjacent_transform =/* unspecified */;// freestandinginlineconstexprauto pairwise_transform = adjacent_transform<2>;// freestanding} // chunk viewtemplate<view V> requires input_range<V>class chunk_view;// freestanding template<view V> requires forward_range<V>class chunk_view<V>;// freestanding template<class V>inlineconstexprbool enable_borrowed_range<chunk_view<V>>=// freestanding forward_range<V>&& enable_borrowed_range<V>; namespace views {inlineconstexpr/* unspecified */ chunk =/* unspecified */;}// freestanding // slide viewtemplate<forward_range V> requires view<V>class slide_view;// freestanding template<class V>inlineconstexprbool enable_borrowed_range<slide_view<V>>= enable_borrowed_range<V>;// freestanding namespace views {inlineconstexpr/* unspecified */ slide =/* unspecified */;}// freestanding // chunk by viewtemplate<forward_range V, indirect_binary_predicate<iterator_t<V>, iterator_t<V>> Pred> requires view<V>&& is_object_v<Pred>class chunk_by_view;// freestanding namespace views {inlineconstexpr/* unspecified */ chunk_by =/* unspecified */;}// freestanding // stride viewtemplate<input_range V> requires view<V>class stride_view; template<class V>inlineconstexprbool enable_borrowed_range<stride_view<V>>= enable_borrowed_range<V>; namespace views {inlineconstexpr/* unspecified */ stride =/* unspecified */;} // cartesian product viewtemplate<input_range First, forward_range... Vs> requires (view<First>&& ... && view<Vs>)class cartesian_product_view; namespace views {inlineconstexpr/* unspecified */ cartesian_product =/* unspecified */;}} namespace std {namespace views = ranges::views;// freestanding template<class T>struct tuple_size;// freestandingtemplate<size_t I, class T>struct tuple_element;// freestanding template<class I, class S, ranges::subrange_kind K>struct tuple_size<ranges::subrange<I, S, K>>// freestanding: integral_constant<size_t, 2>{};template<class I, class S, ranges::subrange_kind K>struct tuple_element<0, ranges::subrange<I, S, K>>{// freestandingusing type = I;// freestanding};template<class I, class S, ranges::subrange_kind K>struct tuple_element<1, ranges::subrange<I, S, K>>{// freestandingusing type = S;// freestanding};template<class I, class S, ranges::subrange_kind K>struct tuple_element<0, constranges::subrange<I, S, K>>{// freestandingusing type = I;// freestanding};template<class I, class S, ranges::subrange_kind K>struct tuple_element<1, constranges::subrange<I, S, K>>{// freestandingusing type = S;// freestanding}; struct from_range_t {explicit from_range_t()=default;};// freestandinginlineconstexpr from_range_t from_range{};// freestanding}
[править]Концепт range
namespace std::ranges{template<class T > concept range = requires(T& t){ranges::begin(t);// equality-preserving for forward iteratorsranges::end(t);};}
[править]Концепт borrowed_range
namespace std::ranges{template<class T> concept borrowed_range = range<T>&&(is_lvalue_reference_v<T>|| enable_borrowed_range<remove_cvref_t<T>>);}
[править]Концепт sized_range
namespace std::ranges{template<class T > concept sized_range = range<T>&& requires(T& t){ranges::size(t);};}
[править]Концепт view
namespace std::ranges{template<class T>inlineconstexprbool enable_view = derived_from<T, view_base>; template<class T> concept view = range<T>&& movable<T>&& enable_view<T>;}
[править]Концепт output_range
namespace std::ranges{template<class R, class T> concept output_range = range<R>&& output_iterator<iterator_t<R>, T>;}
[править]Концепт input_range
namespace std::ranges{template<class T> concept input_range = range<T>&& input_iterator<iterator_t<T>>;}
[править]Концепт forward_range
namespace std::ranges{template<class T> concept forward_range = input_range<T>&& forward_iterator<iterator_t<T>>;}
[править]Концепт bidirectional_range
namespace std::ranges{template<class T> concept bidirectional_range = forward_range<T>&& bidirectional_iterator<iterator_t<T>>;}
[править]Концепт random_access_range
namespace std::ranges{template<class T> concept random_access_range = bidirectional_range<T>&& random_access_iterator<iterator_t<T>>;}
[править]Концепт contiguous_range
namespace std::ranges{template<class T> concept contiguous_range = random_access_range<T>&& contiguous_iterator<iterator_t<T>>&& requires(T& t){{ranges::data(t)}-> same_as<add_pointer_t<range_reference_t<T>>>;};}
[править]Концепт common_range
namespace std::ranges{template<class T> concept common_range = range<T>&& same_as<iterator_t<T>, sentinel_t<T>>;}
[править]Концепт viewable_range
namespace std::ranges{template<class T> concept viewable_range = range<T>&&(borrowed_range<T>|| view<remove_cvref_t<T>>);}
[править]Вспомогательные концепты
Заметка: Следующие имена предназначены только для пояснения, они не являются частью интерфейса.
namespace std::ranges{// unspecified, for name lookup onlytemplate<class R> concept __simple_view =// exposition only view<R>&& range<const R>&& same_as<iterator_t<R>, iterator_t<const R>>&& same_as<sentinel_t<R>, sentinel_t<const R>>; template<class I> concept __has_arrow =// exposition only input_iterator<I>&&(is_pointer_v<I>|| requires(I i){ i.operator->();}); template<class T, class U> concept __different_from =// exposition only!same_as<remove_cvref_t<T>, remove_cvref_t<U>>;}
[править]Шаблон класса std::ranges::view_interface
namespace std::ranges{template<class D> requires is_class_v<D>&& same_as<D, remove_cv_t<D>>class view_interface {private:constexpr D& derived()noexcept{// exposition onlyreturnstatic_cast<D&>(*this);}constexprconst D& derived()constnoexcept{// exposition onlyreturnstatic_cast<const D&>(*this);} public:constexprbool empty() requires sized_range<D>|| forward_range<D>{ifconstexpr(sized_range<D>)returnranges::size(derived())==0;elsereturnranges::begin(derived())==ranges::end(derived());}constexprbool empty()const requires sized_range<const D>|| forward_range<const D>{ifconstexpr(sized_range<const D>)returnranges::size(derived())==0;elsereturnranges::begin(derived())==ranges::end(derived());} constexprauto cbegin(){returnranges::cbegin(derived());}constexprauto cbegin()const requires range<const D>{returnranges::cbegin(derived());}constexprauto cend(){returnranges::cend(derived());}constexprauto cend()const requires range<const D>{returnranges::cend(derived());} constexprexplicit operator bool() requires requires {ranges::empty(derived());}{return!ranges::empty(derived());}constexprexplicit operator bool()const requires requires {ranges::empty(derived());}{return!ranges::empty(derived());} constexprauto data() requires contiguous_iterator<iterator_t<D>>{return to_address(ranges::begin(derived()));}constexprauto data()const requires range<const D>&& contiguous_iterator<iterator_t<const D>>{return to_address(ranges::begin(derived()));} constexprauto size() requires forward_range<D>&& sized_sentinel_for<sentinel_t<D>, iterator_t<D>>{returnranges::end(derived())-ranges::begin(derived());}constexprauto size()const requires forward_range<const D>&& sized_sentinel_for<sentinel_t<const D>, iterator_t<const D>>{returnranges::end(derived())-ranges::begin(derived());} constexpr decltype(auto) front() requires forward_range<D>;constexpr decltype(auto) front()const requires forward_range<const D>; constexpr decltype(auto) back() requires bidirectional_range<D>&& common_range<D>;constexpr decltype(auto) back()const requires bidirectional_range<const D>&& common_range<const D>; template<random_access_range R = D>constexpr decltype(auto) operator[](range_difference_t<R> n){returnranges::begin(derived())[n];}template<random_access_range R =const D>constexpr decltype(auto) operator[](range_difference_t<R> n)const{returnranges::begin(derived())[n];}};}
[править]Шаблон класса std::ranges::subrange
namespace std::ranges{template<class From, class To> concept __uses_nonqualification_pointer_conversion =// exposition only is_pointer_v<From>&& is_pointer_v<To>&&!convertible_to<remove_pointer_t<From>(*)[], remove_pointer_t<To>(*)[]>; template<class From, class To> concept __convertible_to_non_slicing =// exposition only convertible_to<From, To>&&!__uses_nonqualification_pointer_conversion<decay_t<From>, decay_t<To>>; template<class T, class U, class V> concept __pair_like_convertible_from =// exposition only!range<T>&&!is_reference_v<T>&& __pair_like<T>&& constructible_from<T, U, V>&& __convertible_to_non_slicing<U, tuple_element_t<0, T>>&& convertible_to<V, tuple_element_t<1, T>>; template<input_or_output_iterator I, sentinel_for<I> S = I, subrange_kind K = sized_sentinel_for<S, I>? subrange_kind::sized: subrange_kind::unsized> requires (K == subrange_kind::sized||!sized_sentinel_for<S, I>)class subrange :public view_interface<subrange<I, S, K>>{private:staticconstexprbool StoreSize =// exposition only K == subrange_kind::sized&&!sized_sentinel_for<S, I>; I begin_ = I();// exposition only S end_ = S();// exposition only __make_unsigned_like_t<iter_difference_t<I>> size_ =0;// exposition only; present only when StoreSize is truepublic: subrange() requires default_initializable<I>=default; constexpr subrange(__convertible_to_non_slicing<I>auto i, S s) requires (!StoreSize); constexpr subrange(__convertible_to_non_slicing<I>auto i, S s, __make_unsigned_like_t<iter_difference_t<I>> n) requires (K == subrange_kind::sized); template<__different_from<subrange> R> requires borrowed_range<R>&& __convertible_to_non_slicing<iterator_t<R>, I>&& convertible_to<sentinel_t<R>, S>constexpr subrange(R&& r) requires (!StoreSize || sized_range<R>); template<borrowed_range R> requires __convertible_to_non_slicing<iterator_t<R>, I>&& convertible_to<sentinel_t<R>, S>constexpr subrange(R&& r, __make_unsigned_like_t<iter_difference_t<I>> n) requires (K == subrange_kind::sized): subrange{ranges::begin(r), ranges::end(r), n}{} template<__different_from<subrange> PairLike> requires __pair_like_convertible_from<PairLike, const I&, const S&>constexpr operator PairLike()const; constexpr I begin()const requires copyable<I>;[[nodiscard]]constexpr I begin() requires (!copyable<I>);constexpr S end()const; constexprbool empty()const;constexpr __make_unsigned_like_t<iter_difference_t<I>> size()const requires (K == subrange_kind::sized); [[nodiscard]]constexpr subrange next(iter_difference_t<I> n =1)const& requires forward_iterator<I>;[[nodiscard]]constexpr subrange next(iter_difference_t<I> n =1)&&;[[nodiscard]]constexpr subrange prev(iter_difference_t<I> n =1)const requires bidirectional_iterator<I>;constexpr subrange& advance(iter_difference_t<I> n);}; template<input_or_output_iterator I, sentinel_for<I> S> subrange(I, S)-> subrange<I, S>; template<input_or_output_iterator I, sentinel_for<I> S> subrange(I, S, __make_unsigned_like_t<iter_difference_t<I>>)-> subrange<I, S, subrange_kind::sized>; template<borrowed_range R> subrange(R&&)-> subrange<iterator_t<R>, sentinel_t<R>, (sized_range<R>|| sized_sentinel_for<sentinel_t<R>, iterator_t<R>>)? subrange_kind::sized: subrange_kind::unsized>; template<borrowed_range R> subrange(R&&, __make_unsigned_like_t<range_difference_t<R>>)-> subrange<iterator_t<R>, sentinel_t<R>, subrange_kind::sized>;}
[править]Класс std::ranges::dangling
namespace std::ranges{struct dangling {constexpr dangling()noexcept=default;constexpr dangling(auto&&...)noexcept{}};}
[править]Класс std::ranges::elements_of
namespace std::ranges{template<range R, class Allocator = allocator<byte>>struct elements_of {[[no_unique_address]] R range;[[no_unique_address]] Allocator allocator = Allocator();}; template<class R, class Allocator = allocator<byte>> elements_of(R&&, Allocator = Allocator())-> elements_of<R&&, Allocator>;}
[править]Шаблон класса std::ranges::empty_view
namespace std::ranges{template<class T> requires is_object_v<T>class empty_view :public view_interface<empty_view<T>>{public:staticconstexpr T* begin()noexcept{return nullptr;}staticconstexpr T* end()noexcept{return nullptr;}staticconstexpr T* data()noexcept{return nullptr;}staticconstexpr size_t size()noexcept{return0;}staticconstexprbool empty()noexcept{returntrue;}};}
[править]Шаблон класса std::ranges::single_view
namespace std::ranges{template<move_constructible T> requires is_object_v<T>class single_view :public view_interface<single_view<T>>{private: __movable_box<T> value_;// exposition only public: single_view() requires default_initializable<T>=default;constexprexplicit single_view(const T& t) requires copy_constructible<T>;constexprexplicit single_view(T&& t);template<class... Args> requires constructible_from<T, Args...>constexprexplicit single_view(in_place_t, Args&&... args); constexpr T* begin()noexcept;constexprconst T* begin()constnoexcept;constexpr T* end()noexcept;constexprconst T* end()constnoexcept;staticconstexpr size_t size()noexcept;constexpr T* data()noexcept;constexprconst T* data()constnoexcept;}; template<class T> single_view(T)-> single_view<T>;}
[править]Шаблон класса std::ranges::iota_view
namespace std::ranges{template<class I> concept decrementable =/* see description */;// exposition only template<class I> concept advanceable =/* see description */;// exposition only template<weakly_incrementable W, semiregular Bound = unreachable_sentinel_t> requires __weakly_equality_comparable_with<W, Bound>&& copyable<W>class iota_view :public view_interface<iota_view<W, Bound>>{private:// class iota_view::iteratorstruct iterator;// exposition only // class iota_view::sentinelstruct sentinel;// exposition only W value_ = W();// exposition only Bound bound_ = Bound();// exposition only public: iota_view() requires default_initializable<W>=default;constexprexplicit iota_view(W value);constexprexplicit iota_view(type_identity_t<W> value, type_identity_t<Bound> bound);constexprexplicit iota_view(iterator first, /* see description */ last); constexpr iterator begin()const;constexprauto end()const;constexpr iterator end()const requires same_as<W, Bound>; constexprauto size()const requires /* see description */;}; template<class W, class Bound> requires (!__is_integer_like<W>||!__is_integer_like<Bound>||(__is_signed_integer_like<W>== __is_signed_integer_like<Bound>)) iota_view(W, Bound)-> iota_view<W, Bound>;}
[править]Шаблон класса std::ranges::iota_view::iterator
namespace std::ranges{template<weakly_incrementable W, semiregular Bound> requires __weakly_equality_comparable_with<W, Bound>&& copyable<W>struct iota_view<W, Bound>::iterator{private: W value_ = W();// exposition onlypublic:using iterator_concept =/* see description */;using iterator_category = input_iterator_tag;// present only if W models// __incrementable and __IOTA_DIFF_T(W) is an integral type using value_type = W;using difference_type = __IOTA_DIFF_T(W); iterator() requires default_initializable<W>=default;constexprexplicit iterator(W value); constexpr W operator*()constnoexcept(is_nothrow_copy_constructible_v<W>); constexpr iterator& operator++();constexprvoid operator++(int);constexpr iterator operator++(int) requires incrementable<W>; constexpr iterator& operator--() requires decrementable<W>;constexpr iterator operator--(int) requires decrementable<W>; constexpr iterator& operator+=(difference_type n) requires advanceable<W>;constexpr iterator& operator-=(difference_type n) requires advanceable<W>;constexpr W operator[](difference_type n)const requires advanceable<W>; friendconstexprbool operator==(const iterator& x, const iterator& y) requires equality_comparable<W>; friendconstexprbool operator<(const iterator& x, const iterator& y) requires totally_ordered<W>;friendconstexprbool operator>(const iterator& x, const iterator& y) requires totally_ordered<W>;friendconstexprbool operator<=(const iterator& x, const iterator& y) requires totally_ordered<W>;friendconstexprbool operator>=(const iterator& x, const iterator& y) requires totally_ordered<W>;friendconstexprauto operator<=>(const iterator& x, const iterator& y) requires totally_ordered<W>&& three_way_comparable<W>; friendconstexpr iterator operator+(iterator i, difference_type n) requires advanceable<W>;friendconstexpr iterator operator+(difference_type n, iterator i) requires advanceable<W>; friendconstexpr iterator operator-(iterator i, difference_type n) requires advanceable<W>;friendconstexpr difference_type operator-(const iterator& x, const iterator& y) requires advanceable<W>;};}
[править]Шаблон класса std::ranges::iota_view::sentinel
namespace std::ranges{template<weakly_incrementable W, semiregular Bound> requires __weakly_equality_comparable_with<W, Bound>&& copyable<W>struct iota_view<W, Bound>::sentinel{private: Bound bound_ = Bound();// exposition onlypublic: sentinel()=default;constexprexplicit sentinel(Bound bound); friendconstexprbool operator==(const iterator& x, const sentinel& y); friendconstexpr iter_difference_t<W> operator-(const iterator& x, const sentinel& y) requires sized_sentinel_for<Bound, W>;friendconstexpr iter_difference_t<W> operator-(const sentinel& x, const iterator& y) requires sized_sentinel_for<Bound, W>;};}
[править]Шаблон класса std::ranges::repeat_view
namespace std::ranges{template<move_constructible W, semiregular Bound = unreachable_sentinel_t> requires (is_object_v<W>&& same_as<W, remove_cv_t<W>>&&(__is_integer_like<Bound>|| same_as<Bound, unreachable_sentinel_t>))class repeat_view :public view_interface<repeat_view<W, Bound>>{private:// class repeat_view::iteratorstruct iterator;// exposition only __movable_box<W> value_ = W();// exposition only Bound bound_ = Bound();// exposition only public: repeat_view() requires default_initializable<W>=default; constexprexplicit repeat_view(const W& value, Bound bound = Bound()) requires copy_constructible<W>;constexprexplicit repeat_view(W&& value, Bound bound = Bound());template<class... WArgs, class... BoundArgs> requires constructible_from<W, WArgs...>&& constructible_from<Bound, BoundArgs...>constexprexplicit repeat_view(piecewise_construct_t, tuple<WArgs...> value_args, tuple<BoundArgs...> bound_args = tuple<>{}); constexpr iterator begin()const;constexpr iterator end()const requires (!same_as<Bound, unreachable_sentinel_t>);constexpr unreachable_sentinel_t end()constnoexcept; constexprauto size()const requires (!same_as<Bound, unreachable_sentinel_t>);}; template<class W, class Bound> repeat_view(W, Bound)-> repeat_view<W, Bound>;}
[править]Шаблон класса std::ranges::repeat_view::iterator
namespace std::ranges{template<move_constructible W, semiregular Bound = unreachable_sentinel_t> requires (is_object_v<W>&& same_as<W, remove_cv_t<W>>&&(__is_integer_like<Bound>|| same_as<Bound, unreachable_sentinel_t>))class repeat_view<W, Bound>::iterator{private:using __index_type =// exposition only conditional_t<same_as<Bound, unreachable_sentinel_t>, ptrdiff_t, Bound>;const W* value_ = nullptr;// exposition only __index_type current_ = __index_type();// exposition only constexprexplicit iterator(const W* value, __index_type b = __index_type());// exposition only public:using iterator_concept = random_access_iterator_tag;using iterator_category = random_access_iterator_tag;using value_type = W;using difference_type = conditional_t<__is_signed_integer_like<__index_type>, __index_type, __IOTA_DIFF_T(__index_type)>; iterator()=default; constexprconst W& operator*()constnoexcept; constexpr iterator& operator++();constexpr iterator operator++(int); constexpr iterator& operator--();constexpr iterator operator--(int); constexpr iterator& operator+=(difference_type n);constexpr iterator& operator-=(difference_type n);constexprconst W& operator[](difference_type n)constnoexcept; friendconstexprbool operator==(const iterator& x, const iterator& y);friendconstexprauto operator<=>(const iterator& x, const iterator& y); friendconstexpr iterator operator+(iterator i, difference_type n);friendconstexpr iterator operator+(difference_type n, iterator i); friendconstexpr iterator operator-(iterator i, difference_type n);friendconstexpr difference_type operator-(const iterator& x, const iterator& y);};}
[править]Шаблон класса std::ranges::basic_istream_view
namespace std::ranges{template<class Val, class CharT, class Traits> concept __stream_extractable =// exposition only requires(basic_istream<CharT, Traits>& is, Val& t){ is >> t;}; template<movable Val, class CharT, class Traits = char_traits<CharT>> requires default_initializable<Val>&& __stream_extractable<Val, CharT, Traits>class basic_istream_view :public view_interface<basic_istream_view<Val, CharT, Traits>>{public:constexprexplicit basic_istream_view(basic_istream<CharT, Traits>& stream); constexprauto begin(){*stream_ >> value_;return iterator{*this};} constexpr default_sentinel_t end()constnoexcept; private:// class basic_istream_view::iteratorstruct iterator;// exposition only basic_istream<CharT, Traits>* stream_;// exposition only Val value_ = Val();// exposition only};}
[править]Шаблон класса std::ranges::basic_istream_view::iterator
namespace std::ranges{template<movable Val, class CharT, class Traits> requires default_initializable<Val>&& __stream_extractable<Val, CharT, Traits>class basic_istream_view<Val, CharT, Traits>::iterator{public:using iterator_concept = input_iterator_tag;using difference_type = ptrdiff_t;using value_type = Val; constexprexplicit iterator(basic_istream_view& parent)noexcept; iterator(const iterator&)= delete; iterator(iterator&&)=default; iterator& operator=(const iterator&)= delete; iterator& operator=(iterator&&)=default; iterator& operator++();void operator++(int); Val& operator*()const; friendbool operator==(const iterator& x, default_sentinel_t); private: basic_istream_view* parent_;// exposition only};}
[править]Шаблон класса std::ranges::ref_view
namespace std::ranges{template<range R> requires is_object_v<R>class ref_view :public view_interface<ref_view<R>>{private: R* r_;// exposition onlypublic:template<__different_from<ref_view> T> requires /* see description */constexpr ref_view(T&& t); constexpr R& base()const{return*r_;} constexpr iterator_t<R> begin()const{returnranges::begin(*r_);}constexpr sentinel_t<R> end()const{returnranges::end(*r_);} constexprbool empty()const requires requires {ranges::empty(*r_);}{returnranges::empty(*r_);} constexprauto size()const requires sized_range<R>{returnranges::size(*r_);} constexprauto data()const requires contiguous_range<R>{returnranges::data(*r_);}}; template<class R> ref_view(R&)-> ref_view<R>;}
[править]Шаблон класса std::ranges::owning_view
namespace std::ranges{template<range R> requires movable<R>&&(!__is_initializer_list<R>)class owning_view :public view_interface<owning_view<R>>{private: R r_ = R();// exposition onlypublic: owning_view() requires default_initializable<R>=default;constexpr owning_view(R&& t); owning_view(owning_view&&)=default; owning_view& operator=(owning_view&&)=default; constexpr R& base()&noexcept{return r_;}constexprconst R& base()const&noexcept{return r_;}constexpr R&& base()&&noexcept{return std::move(r_);}constexprconst R&& base()const&&noexcept{return std::move(r_);} constexpr iterator_t<R> begin(){returnranges::begin(r_);}constexpr sentinel_t<R> end(){returnranges::end(r_);} constexprauto begin()const requires range<const R>{returnranges::begin(r_);}constexprauto end()const requires range<const R>{returnranges::end(r_);} constexprbool empty() requires requires {ranges::empty(r_);}{returnranges::empty(r_);}constexprbool empty()const requires requires {ranges::empty(r_);}{returnranges::empty(r_);} constexprauto size() requires sized_range<R>{returnranges::size(r_);}constexprauto size()const requires sized_range<const R>{returnranges::size(r_);} constexprauto data() requires contiguous_range<R>{returnranges::data(r_);}constexprauto data()const requires contiguous_range<const R>{returnranges::data(r_);}};}
[править]Шаблон класса std::ranges::as_rvalue_view
namespace std::ranges{template<view V> requires input_range<V>class as_rvalue_view :public view_interface<as_rvalue_view<V>>{ V base_ = V();// exposition only public: as_rvalue_view() requires default_initializable<V>=default;constexprexplicit as_rvalue_view(V base); constexpr V base()const& requires copy_constructible<V>{return base_;}constexpr V base()&&{return std::move(base_);} constexprauto begin() requires (!__simple_view<V>){return move_iterator(ranges::begin(base_));}constexprauto begin()const requires range<const V>{return move_iterator(ranges::begin(base_));} constexprauto end() requires (!__simple_view<V>){ifconstexpr(common_range<V>){return move_iterator(ranges::end(base_));}else{return move_sentinel(ranges::end(base_));}}constexprauto end()const requires range<const V>{ifconstexpr(common_range<const V>){return move_iterator(ranges::end(base_));}else{return move_sentinel(ranges::end(base_));}} constexprauto size() requires sized_range<V>{returnranges::size(base_);}constexprauto size()const requires sized_range<const V>{returnranges::size(base_);}}; template<class R> as_rvalue_view(R&&)-> as_rvalue_view<views::all_t<R>>;}
[править]Шаблон класса std::ranges::filter_view
namespace std::ranges{template<input_range V, indirect_unary_predicate<iterator_t<V>> Pred> requires view<V>&& is_object_v<Pred>class filter_view :public view_interface<filter_view<V, Pred>>{private: V base_ = V();// exposition only __movable_box<Pred> pred_;// exposition only // class filter_view::iteratorclass iterator;// exposition only // class filter_view::sentinelclass sentinel;// exposition only public: filter_view() requires default_initializable<V>&& default_initializable<Pred>=default;constexprexplicit filter_view(V base, Pred pred); constexpr V base()const& requires copy_constructible<V>{return base_;}constexpr V base()&&{return std::move(base_);} constexprconst Pred& pred()const; constexpr iterator begin();constexprauto end(){ifconstexpr(common_range<V>)return iterator{*this, ranges::end(base_)};elsereturn sentinel{*this};}}; template<class R, class Pred> filter_view(R&&, Pred)-> filter_view<views::all_t<R>, Pred>;}
[править]Шаблон класса std::ranges::filter_view::iterator
namespace std::ranges{template<input_range V, indirect_unary_predicate<iterator_t<V>> Pred> requires view<V>&& is_object_v<Pred>class filter_view<V, Pred>::iterator{private: iterator_t<V> current_ = iterator_t<V>();// exposition only filter_view* parent_ = nullptr;// exposition only public:using iterator_concept =/* see description */;using iterator_category =/* see description */;// not always presentusing value_type = range_value_t<V>;using difference_type = range_difference_t<V>; iterator() requires default_initializable<iterator_t<V>>=default;constexpr iterator(filter_view& parent, iterator_t<V> current); constexprconst iterator_t<V>& base()const&noexcept;constexpr iterator_t<V> base()&&;constexpr range_reference_t<V> operator*()const;constexpr iterator_t<V> operator->()const requires __has_arrow<iterator_t<V>>&& copyable<iterator_t<V>>; constexpr iterator& operator++();constexprvoid operator++(int);constexpr iterator operator++(int) requires forward_range<V>; constexpr iterator& operator--() requires bidirectional_range<V>;constexpr iterator operator--(int) requires bidirectional_range<V>; friendconstexprbool operator==(const iterator& x, const iterator& y) requires equality_comparable<iterator_t<V>>; friendconstexpr range_rvalue_reference_t<V> iter_move(const iterator& i)noexcept(noexcept(ranges::iter_move(i.current_))); friendconstexprvoid iter_swap(const iterator& x, const iterator& y)noexcept(noexcept(ranges::iter_swap(x.current_, y.current_))) requires indirectly_swappable<iterator_t<V>>;};}
[править]Шаблон класса std::ranges::filter_view::sentinel
namespace std::ranges{template<input_range V, indirect_unary_predicate<iterator_t<V>> Pred> requires view<V>&& is_object_v<Pred>class filter_view<V, Pred>::sentinel{private: sentinel_t<V> end_ = sentinel_t<V>();// exposition only public: sentinel()=default;constexprexplicit sentinel(filter_view& parent); constexpr sentinel_t<V> base()const; friendconstexprbool operator==(const iterator& x, const sentinel& y);};}
[править]Шаблон класса std::ranges::transform_view
namespace std::ranges{template<input_range V, move_constructible F> requires view<V>&& is_object_v<F>&& regular_invocable<F&, range_reference_t<V>>&& __can_reference<invoke_result_t<F&, range_reference_t<V>>>class transform_view :public view_interface<transform_view<V, F>>{private:// class template transform_view::iteratortemplate<bool>struct iterator;// exposition only // class template transform_view::sentineltemplate<bool>struct sentinel;// exposition only V base_ = V();// exposition only __movable_box<F> fun_;// exposition only public: transform_view() requires default_initializable<V>&& default_initializable<F>=default;constexprexplicit transform_view(V base, F fun); constexpr V base()const& requires copy_constructible<V>{return base_;}constexpr V base()&&{return std::move(base_);} constexpr iterator<false> begin();constexpr iterator<true> begin()const requires range<const V>&& regular_invocable<const F&, range_reference_t<const V>>; constexpr sentinel<false> end();constexpr iterator<false> end() requires common_range<V>;constexpr sentinel<true> end()const requires range<const V>&& regular_invocable<const F&, range_reference_t<const V>>;constexpr iterator<true> end()const requires common_range<const V>&& regular_invocable<const F&, range_reference_t<const V>>; constexprauto size() requires sized_range<V>{returnranges::size(base_);}constexprauto size()const requires sized_range<const V>{returnranges::size(base_);}}; template<class R, class F> transform_view(R&&, F)-> transform_view<views::all_t<R>, F>;}
[править]Шаблон класса std::ranges::transform_view::iterator
namespace std::ranges{template<input_range V, move_constructible F> requires view<V>&& is_object_v<F>&& regular_invocable<F&, range_reference_t<V>>&& __can_reference<invoke_result_t<F&, range_reference_t<V>>>template<bool Const>class transform_view<V, F>::iterator{private:using Parent = __maybe_const<Const, transform_view>;// exposition onlyusing Base = __maybe_const<Const, V>;// exposition only iterator_t<Base> current_ = iterator_t<Base>();// exposition only Parent* parent_ = nullptr;// exposition only public:using iterator_concept =/* see description */;using iterator_category =/* see description */;// not always presentusing value_type = remove_cvref_t<invoke_result_t<__maybe_const<Const, F>&, range_reference_t<Base>>>;using difference_type = range_difference_t<Base>; iterator() requires default_initializable<iterator_t<Base>>=default;constexpr iterator(Parent& parent, iterator_t<Base> current);constexpr iterator(iterator<!Const> i) requires Const && convertible_to<iterator_t<V>, iterator_t<Base>>; constexprconst iterator_t<Base>& base()const&noexcept;constexpr iterator_t<Base> base()&&; constexpr decltype(auto) operator*()constnoexcept(noexcept(invoke(*parent_->fun_, *current_))){return invoke(*parent_->fun_, *current_);} constexpr iterator& operator++();constexprvoid operator++(int);constexpr iterator operator++(int) requires forward_range<Base>; constexpr iterator& operator--() requires bidirectional_range<Base>;constexpr iterator operator--(int) requires bidirectional_range<Base>; constexpr iterator& operator+=(difference_type n) requires random_access_range<Base>;constexpr iterator& operator-=(difference_type n) requires random_access_range<Base>; constexpr decltype(auto) operator[](difference_type n)const requires random_access_range<Base>{return invoke(*parent_->fun_, current_[n]);} friendconstexprbool operator==(const iterator& x, const iterator& y) requires equality_comparable<iterator_t<Base>>; friendconstexprbool operator<(const iterator& x, const iterator& y) requires random_access_range<Base>;friendconstexprbool operator>(const iterator& x, const iterator& y) requires random_access_range<Base>;friendconstexprbool operator<=(const iterator& x, const iterator& y) requires random_access_range<Base>;friendconstexprbool operator>=(const iterator& x, const iterator& y) requires random_access_range<Base>;friendconstexprauto operator<=>(const iterator& x, const iterator& y) requires random_access_range<Base>&& three_way_comparable<iterator_t<Base>>; friendconstexpr iterator operator+(iterator i, difference_type n) requires random_access_range<Base>;friendconstexpr iterator operator+(difference_type n, iterator i) requires random_access_range<Base>; friendconstexpr iterator operator-(iterator i, difference_type n) requires random_access_range<Base>;friendconstexpr difference_type operator-(const iterator& x, const iterator& y) requires sized_sentinel_for<iterator_t<Base>, iterator_t<Base>>;};}
[править]Шаблон класса std::ranges::transform_view::sentinel
namespace std::ranges{template<input_range V, move_constructible F> requires view<V>&& is_object_v<F>&& regular_invocable<F&, range_reference_t<V>>&& __can_reference<invoke_result_t<F&, range_reference_t<V>>>template<bool Const>class transform_view<V, F>::sentinel{private:using Parent = __maybe_const<Const, transform_view>;// exposition onlyusing Base = __maybe_const<Const, V>;// exposition only sentinel_t<Base> end_ = sentinel_t<Base>();// exposition onlypublic: sentinel()=default;constexprexplicit sentinel(sentinel_t<Base> end);constexpr sentinel(sentinel<!Const> i) requires Const && convertible_to<sentinel_t<V>, sentinel_t<Base>>; constexpr sentinel_t<Base> base()const; template<bool OtherConst> requires sentinel_for<sentinel_t<Base>, iterator_t<__maybe_const<OtherConst, V>>>friendconstexprbool operator==(const iterator<OtherConst>& x, const sentinel& y); template<bool OtherConst> requires sized_sentinel_for<sentinel_t<Base>, iterator_t<__maybe_const<OtherConst, V>>>friendconstexpr range_difference_t<__maybe_const<OtherConst, V>> operator-(const iterator<OtherConst>& x, const sentinel& y); template<bool OtherConst> requires sized_sentinel_for<sentinel_t<Base>, iterator_t<__maybe_const<OtherConst, V>>>friendconstexpr range_difference_t<__maybe_const<OtherConst, V>> operator-(const sentinel& y, const iterator<OtherConst>& x);};}
[править]Шаблон класса std::ranges::take_view
namespace std::ranges{template<view V>class take_view :public view_interface<take_view<V>>{private: V base_ = V();// exposition only range_difference_t<V> count_ =0;// exposition only // class template take_view::sentineltemplate<bool>class sentinel;// exposition only public: take_view() requires default_initializable<V>=default;constexprexplicit take_view(V base, range_difference_t<V> count); constexpr V base()const& requires copy_constructible<V>{return base_;}constexpr V base()&&{return std::move(base_);} constexprauto begin() requires (!__simple_view<V>){ifconstexpr(sized_range<V>){ifconstexpr(random_access_range<V>){returnranges::begin(base_);}else{auto sz = range_difference_t<V>(size());return counted_iterator(ranges::begin(base_), sz);}}else{return counted_iterator(ranges::begin(base_), count_);}} constexprauto begin()const requires range<const V>{ifconstexpr(sized_range<const V>){ifconstexpr(random_access_range<const V>){returnranges::begin(base_);}else{auto sz = range_difference_t<const V>(size());return counted_iterator(ranges::begin(base_), sz);}}else{return counted_iterator(ranges::begin(base_), count_);}} constexprauto end() requires (!__simple_view<V>){ifconstexpr(sized_range<V>){ifconstexpr(random_access_range<V>)returnranges::begin(base_)+ range_difference_t<V>(size());elsereturn default_sentinel;}else{return sentinel<false>{ranges::end(base_)};}} constexprauto end()const requires range<const V>{ifconstexpr(sized_range<const V>){ifconstexpr(random_access_range<const V>)returnranges::begin(base_)+ range_difference_t<const V>(size());elsereturn default_sentinel;}else{return sentinel<true>{ranges::end(base_)};}} constexprauto size() requires sized_range<V>{auto n =ranges::size(base_);returnranges::min(n, static_cast<decltype(n)>(count_));} constexprauto size()const requires sized_range<const V>{auto n =ranges::size(base_);returnranges::min(n, static_cast<decltype(n)>(count_));}}; template<class R> take_view(R&&, range_difference_t<R>)-> take_view<views::all_t<R>>;}
[править]Шаблон класса std::ranges::take_view::sentinel
namespace std::ranges{template<view V>template<bool Const>class take_view<V>::sentinel{private:using Base = __maybe_const<Const, V>;// exposition onlytemplate<bool OtherConst>using CI = counted_iterator< iterator_t<__maybe_const<OtherConst, V>>>;// exposition only sentinel_t<Base> end_ = sentinel_t<Base>();// exposition onlypublic: sentinel()=default;constexprexplicit sentinel(sentinel_t<Base> end);constexpr sentinel(sentinel<!Const> s) requires Const && convertible_to<sentinel_t<V>, sentinel_t<Base>>; constexpr sentinel_t<Base> base()const; friendconstexprbool operator==(const CI<Const>& y, const sentinel& x); template<bool OtherConst =!Const> requires sentinel_for<sentinel_t<Base>, iterator_t<__maybe_const<OtherConst, V>>>friendconstexprbool operator==(const CI<OtherConst>& y, const sentinel& x);};}
[править]Шаблон класса std::ranges::take_while_view
namespace std::ranges{template<view V, class Pred> requires input_range<V>&& is_object_v<Pred>&& indirect_unary_predicate<const Pred, iterator_t<V>>class take_while_view :public view_interface<take_while_view<V, Pred>>{// class template take_while_view::sentineltemplate<bool>class sentinel;// exposition only V base_ = V();// exposition only __movable_box<Pred> pred_;// exposition only public: take_while_view() requires default_initializable<V>&& default_initializable<Pred>=default;constexprexplicit take_while_view(V base, Pred pred); constexpr V base()const& requires copy_constructible<V>{return base_;}constexpr V base()&&{return std::move(base_);} constexprconst Pred& pred()const; constexprauto begin() requires (!__simple_view<V>){returnranges::begin(base_);} constexprauto begin()const requires range<const V>&& indirect_unary_predicate<const Pred, iterator_t<const V>>{returnranges::begin(base_);} constexprauto end() requires (!__simple_view<V>){return sentinel<false>(ranges::end(base_), addressof(*pred_));} constexprauto end()const requires range<const V>&& indirect_unary_predicate<const Pred, iterator_t<const V>>{return sentinel<true>(ranges::end(base_), addressof(*pred_));}}; template<class R, class Pred> take_while_view(R&&, Pred)-> take_while_view<views::all_t<R>, Pred>;}
[править]Шаблон класса std::ranges::take_while_view::sentinel
namespace std::ranges{template<view V, class Pred> requires input_range<V>&& is_object_v<Pred>&& indirect_unary_predicate<const Pred, iterator_t<V>>template<bool Const>class take_while_view<V, Pred>::sentinel{using Base = __maybe_const<Const, V>;// exposition only sentinel_t<Base> end_ = sentinel_t<Base>();// exposition onlyconst Pred* pred_ = nullptr;// exposition only public: sentinel()=default;constexprexplicit sentinel(sentinel_t<Base> end, const Pred* pred);constexpr sentinel(sentinel<!Const> s) requires Const && convertible_to<sentinel_t<V>, sentinel_t<Base>>; constexpr sentinel_t<Base> base()const{return end_;} friendconstexprbool operator==(const iterator_t<Base>& x, const sentinel& y); template<bool OtherConst =!Const> requires sentinel_for<sentinel_t<Base>, iterator_t<__maybe_const<OtherConst, V>>>friendconstexprbool operator==(const iterator_t<__maybe_const<OtherConst, V>>& x, const sentinel& y);};}
[править]Шаблон класса std::ranges::drop_view
namespace std::ranges{template<view V>class drop_view :public view_interface<drop_view<V>>{public: drop_view() requires default_initializable<V>=default;constexprexplicit drop_view(V base, range_difference_t<V> count); constexpr V base()const& requires copy_constructible<V>{return base_;}constexpr V base()&&{return std::move(base_);} constexprauto begin() requires (!(__simple_view<V>&& random_access_range<const V>&& sized_range<const V>));constexprauto begin()const requires random_access_range<const V>&& sized_range<const V>; constexprauto end() requires (!__simple_view<V>){returnranges::end(base_);} constexprauto end()const requires range<const V>{returnranges::end(base_);} constexprauto size() requires sized_range<V>{constauto s =ranges::size(base_);constauto c =static_cast<decltype(s)>(count_);return s < c ?0: s - c;} constexprauto size()const requires sized_range<const V>{constauto s =ranges::size(base_);constauto c =static_cast<decltype(s)>(count_);return s < c ?0: s - c;} private: V base_ = V();// exposition only range_difference_t<V> count_ =0;// exposition only}; template<class R> drop_view(R&&, range_difference_t<R>)-> drop_view<views::all_t<R>>;}
[править]Шаблон класса std::ranges::drop_while_view
namespace std::ranges{template<view V, class Pred> requires input_range<V>&& is_object_v<Pred>&& indirect_unary_predicate<const Pred, iterator_t<V>>class drop_while_view :public view_interface<drop_while_view<V, Pred>>{public: drop_while_view() requires default_initializable<V>&& default_initializable<Pred>=default;constexprexplicit drop_while_view(V base, Pred pred); constexpr V base()const& requires copy_constructible<V>{return base_;}constexpr V base()&&{return std::move(base_);} constexprconst Pred& pred()const; constexprauto begin(); constexprauto end(){returnranges::end(base_);} private: V base_ = V();// exposition only __movable_box<Pred> pred_;// exposition only}; template<class R, class Pred> drop_while_view(R&&, Pred)-> drop_while_view<views::all_t<R>, Pred>;}
[править]Шаблон класса std::ranges::join_view
namespace std::ranges{template<input_range V> requires view<V>&& input_range<range_reference_t<V>>class join_view :public view_interface<join_view<V>>{private:using InnerRng = range_reference_t<V>;// exposition only // class template join_view::iteratortemplate<bool Const>struct iterator;// exposition only // class template join_view::sentineltemplate<bool Const>struct sentinel;// exposition only V base_ = V();// exposition only __non_propagating_cache<remove_cv_t<InnerRng>> inner_;// exposition only, present only// when !is_reference_v<InnerRng> public: join_view() requires default_initializable<V>=default;constexprexplicit join_view(V base); constexpr V base()const& requires copy_constructible<V>{return base_;}constexpr V base()&&{return std::move(base_);} constexprauto begin(){constexprbool use_const = __simple_view<V>&& is_reference_v<InnerRng>;return iterator<use_const>{*this, ranges::begin(base_)};} constexprauto begin()const requires input_range<const V>&& is_reference_v<range_reference_t<const V>>{return iterator<true>{*this, ranges::begin(base_)};} constexprauto end(){ifconstexpr(forward_range<V>&& is_reference_v<InnerRng>&& forward_range<InnerRng>&& common_range<V>&& common_range<InnerRng>)return iterator<__simple_view<V>>{*this, ranges::end(base_)};elsereturn sentinel<__simple_view<V>>{*this};} constexprauto end()const requires input_range<const V>&& is_reference_v<range_reference_t<const V>>{ifconstexpr(forward_range<const V>&& forward_range<range_reference_t<const V>>&& common_range<const V>&& common_range<range_reference_t<const V>>)return iterator<true>{*this, ranges::end(base_)};elsereturn sentinel<true>{*this};}}; template<class R>explicit join_view(R&&)-> join_view<views::all_t<R>>;}
[править]Шаблон класса std::ranges::join_view::iterator
namespace std::ranges{template<input_range V> requires view<V>&& input_range<range_reference_t<V>>template<bool Const>struct join_view<V>::iterator{private:using Parent = __maybe_const<Const, join_view>;// exposition onlyusing Base = __maybe_const<Const, V>;// exposition onlyusing OuterIter = iterator_t<Base>;// exposition onlyusing InnerIter = iterator_t<range_reference_t<Base>>;// exposition only staticconstexprbool __ref_is_glvalue =// exposition only is_reference_v<range_reference_t<Base>>; OuterIter outer_ = OuterIter();// exposition only InnerIter inner_ = InnerIter();// exposition only Parent* parent_ = nullptr;// exposition only constexprvoid satisfy();// exposition only public:using iterator_concept =/* see description */;using iterator_category =/* see description */;// not always presentusing value_type = range_value_t<range_reference_t<Base>>;using difference_type =/* see description */; iterator() requires default_initializable<OuterIter>&& default_initializable<InnerIter>=default;constexpr iterator(Parent& parent, OuterIter outer);constexpr iterator(iterator<!Const> i) requires Const && convertible_to<iterator_t<V>, OuterIter>&& convertible_to<iterator_t<InnerRng>, InnerIter>; constexpr decltype(auto) operator*()const{return*inner_;} constexpr InnerIter operator->()const requires __has_arrow<InnerIter>&& copyable<InnerIter>; constexpr iterator& operator++();constexprvoid operator++(int);constexpr iterator operator++(int) requires __ref_is_glvalue && forward_range<Base>&& forward_range<range_reference_t<Base>>; constexpr iterator& operator--() requires __ref_is_glvalue && bidirectional_range<Base>&& bidirectional_range<range_reference_t<Base>>&& common_range<range_reference_t<Base>>; constexpr iterator operator--(int) requires __ref_is_glvalue && bidirectional_range<Base>&& bidirectional_range<range_reference_t<Base>>&& common_range<range_reference_t<Base>>; friendconstexprbool operator==(const iterator& x, const iterator& y) requires __ref_is_glvalue && equality_comparable<iterator_t<Base>>&& equality_comparable<iterator_t<range_reference_t<Base>>>; friendconstexpr decltype(auto) iter_move(const iterator& i)noexcept(noexcept(ranges::iter_move(i.inner_))){returnranges::iter_move(i.inner_);} friendconstexprvoid iter_swap(const iterator& x, const iterator& y)noexcept(noexcept(ranges::iter_swap(x.inner_, y.inner_))) requires indirectly_swappable<InnerIter>;};}
[править]Шаблон класса std::ranges::join_view::sentinel
namespace std::ranges{template<input_range V> requires view<V>&& input_range<range_reference_t<V>>template<bool Const>struct join_view<V>::sentinel{private:using Parent = __maybe_const<Const, join_view>;// exposition onlyusing Base = __maybe_const<Const, V>;// exposition only sentinel_t<Base> end_ = sentinel_t<Base>();// exposition only public: sentinel()=default; constexprexplicit sentinel(Parent& parent);constexpr sentinel(sentinel<!Const> s) requires Const && convertible_to<sentinel_t<V>, sentinel_t<Base>>; template<bool OtherConst> requires sentinel_for<sentinel_t<Base>, iterator_t<__maybe_const<OtherConst, V>>>friendconstexprbool operator==(const iterator<OtherConst>& x, const sentinel& y);};}
[править]Шаблон класса std::ranges::join_with_view
namespace std::ranges{template<class R, class P> concept __compatible_joinable_ranges =// exposition only common_with<range_value_t<R>, range_value_t<P>>&& common_reference_with<range_reference_t<R>, range_reference_t<P>>&& common_reference_with<range_rvalue_reference_t<R>, range_rvalue_reference_t<P>>; template<class R> concept __bidirectional_common = bidirectional_range<R>&& common_range<R>;// exposition only template<input_range V, forward_range Pattern> requires view<V>&& input_range<range_reference_t<V>>&& view<Pattern>&& __compatible_joinable_ranges<range_reference_t<V>, Pattern>class join_with_view :public view_interface<join_with_view<V, Pattern>>{using InnerRng = range_reference_t<V>;// exposition only V base_ = V();// exposition only __non_propagating_cache<remove_cv_t<InnerRng>> inner_;// exposition only, present only// when !is_reference_v<InnerRng> Pattern pattern_ = Pattern();// exposition only // class template join_with_view::iteratortemplate<bool Const>struct iterator;// exposition only // class template join_with_view::sentineltemplate<bool Const>struct sentinel;// exposition only public: join_with_view() requires default_initializable<V>&& default_initializable<Pattern>=default; constexprexplicit join_with_view(V base, Pattern pattern); template<input_range R> requires constructible_from<V, views::all_t<R>>&& constructible_from<Pattern, single_view<range_value_t<InnerRng>>>constexprexplicit join_with_view(R&& r, range_value_t<InnerRng> e); constexpr V base()const& requires copy_constructible<V>{return base_;}constexpr V base()&&{return std::move(base_);} constexprauto begin(){constexprbool use_const = __simple_view<V>&& is_reference_v<InnerRng>&& __simple_view<Pattern>;return iterator<use_const>{*this, ranges::begin(base_)};}constexprauto begin()const requires input_range<const V>&& forward_range<const Pattern>&& is_reference_v<range_reference_t<const V>>{return iterator<true>{*this, ranges::begin(base_)};} constexprauto end(){ifconstexpr(forward_range<V>&& is_reference_v<InnerRng>&& forward_range<InnerRng>&& common_range<V>&& common_range<InnerRng>)return iterator<__simple_view<V>&& __simple_view<Pattern>>{*this, ranges::end(base_)};elsereturn sentinel<__simple_view<V>&& __simple_view<Pattern>>{*this};}constexprauto end()const requires input_range<const V>&& forward_range<const Pattern>&& is_reference_v<range_reference_t<const V>>{using InnerConstRng = range_reference_t<const V>;ifconstexpr(forward_range<const V>&& forward_range<InnerConstRng>&& common_range<const V>&& common_range<InnerConstRng>)return iterator<true>{*this, ranges::end(base_)};elsereturn sentinel<true>{*this};}}; template<class R, class P> join_with_view(R&&, P&&)-> join_with_view<views::all_t<R>, views::all_t<P>>; template<input_range R> join_with_view(R&&, range_value_t<range_reference_t<R>>)-> join_with_view<views::all_t<R>, single_view<range_value_t<range_reference_t<R>>>>;}
[править]Шаблон класса std::ranges::join_with_view::iterator
namespace std::ranges{template<input_range V, forward_range Pattern> requires view<V>&& input_range<range_reference_t<V>>&& view<Pattern>&& __compatible_joinable_ranges<range_reference_t<V>, Pattern>template<bool Const>class join_with_view<V, Pattern>::iterator{using Parent = __maybe_const<Const, join_with_view>;// exposition onlyusing Base = __maybe_const<Const, V>;// exposition onlyusing InnerBase = range_reference_t<Base>;// exposition onlyusing PatternBase = __maybe_const<Const, Pattern>;// exposition only using OuterIter = iterator_t<Base>;// exposition onlyusing InnerIter = iterator_t<InnerBase>;// exposition onlyusing PatternIter = iterator_t<PatternBase>;// exposition only staticconstexprbool __ref_is_glvalue = is_reference_v<InnerBase>;// exposition only Parent* parent_ = nullptr;// exposition only OuterIter outer_it_ = OuterIter();// exposition only variant<PatternIter, InnerIter> inner_it_;// exposition only constexpr iterator(Parent& parent, iterator_t<Base> outer);// exposition onlyconstexprauto&& __update_inner(const OuterIter&);// exposition onlyconstexprauto&& __get_inner(const OuterIter&);// exposition onlyconstexprvoid satisfy();// exposition only public:using iterator_concept =/* see description */;using iterator_category =/* see description */;// not always presentusing value_type =/* see description */;using difference_type =/* see description */; iterator() requires default_initializable<OuterIter>=default;constexpr iterator(iterator<!Const> i) requires Const && convertible_to<iterator_t<V>, OuterIter>&& convertible_to<iterator_t<InnerRng>, InnerIter>&& convertible_to<iterator_t<Pattern>, PatternIter>; constexpr decltype(auto) operator*()const; constexpr iterator& operator++();constexprvoid operator++(int);constexpr iterator operator++(int) requires __ref_is_glvalue && forward_iterator<OuterIter>&& forward_iterator<InnerIter>; constexpr iterator& operator--() requires __ref_is_glvalue && bidirectional_range<Base>&& __bidirectional_common<InnerBase>&& __bidirectional_common<PatternBase>;constexpr iterator operator--(int) requires __ref_is_glvalue && bidirectional_range<Base>&& __bidirectional_common<InnerBase>&& __bidirectional_common<PatternBase>; friendconstexprbool operator==(const iterator& x, const iterator& y) requires __ref_is_glvalue && equality_comparable<OuterIter>&& equality_comparable<InnerIter>; friendconstexpr decltype(auto) iter_move(const iterator& x){using rvalue_reference = common_reference_t< iter_rvalue_reference_t<InnerIter>, iter_rvalue_reference_t<PatternIter>>;return visit<rvalue_reference>(ranges::iter_move, x.inner_it_);} friendconstexprvoid iter_swap(const iterator& x, const iterator& y) requires indirectly_swappable<InnerIter, PatternIter>{ visit(ranges::iter_swap, x.inner_it_, y.inner_it_);}};}
[править]Шаблон класса std::ranges::join_with_view::sentinel
namespace std::ranges{template<input_range V, forward_range Pattern> requires view<V>&& input_range<range_reference_t<V>>&& view<Pattern>&& __compatible_joinable_ranges<range_reference_t<V>, Pattern>template<bool Const>class join_with_view<V, Pattern>::sentinel{using Parent = __maybe_const<Const, join_with_view>;// exposition onlyusing Base = __maybe_const<Const, V>;// exposition only sentinel_t<Base> end_ = sentinel_t<Base>();// exposition only constexprexplicit sentinel(Parent& parent);// exposition only public: sentinel()=default;constexpr sentinel(sentinel<!Const> s) requires Const && convertible_to<sentinel_t<V>, sentinel_t<Base>>; template<bool OtherConst> requires sentinel_for<sentinel_t<Base>, iterator_t<__maybe_const<OtherConst, V>>>friendconstexprbool operator==(const iterator<OtherConst>& x, const sentinel& y);};}
[править]Шаблон класса std::ranges::lazy_split_view
namespace std::ranges{template<auto>struct __require_constant;// exposition only template<class R> concept __tiny_range =// exposition only sized_range<R>&& requires {typename __require_constant<remove_reference_t<R>::size()>;}&&(remove_reference_t<R>::size()<=1); template<input_range V, forward_range Pattern> requires view<V>&& view<Pattern>&& indirectly_comparable<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to>&&(forward_range<V>|| __tiny_range<Pattern>)class lazy_split_view :public view_interface<lazy_split_view<V, Pattern>>{private: V base_ = V();// exposition only Pattern pattern_ = Pattern();// exposition only __non_propagating_cache<iterator_t<V>> current_;// exposition only, present only// if !forward_range<V> // class template lazy_split_view::outer-iteratortemplate<bool>struct __outer_iterator;// exposition only // class template lazy_split_view::inner-iteratortemplate<bool>struct __inner_iterator;// exposition only public: lazy_split_view() requires default_initializable<V>&& default_initializable<Pattern>=default;constexprexplicit lazy_split_view(V base, Pattern pattern); template<input_range R> requires constructible_from<V, views::all_t<R>>&& constructible_from<Pattern, single_view<range_value_t<R>>>constexprexplicit lazy_split_view(R&& r, range_value_t<R> e); constexpr V base()const& requires copy_constructible<V>{return base_;}constexpr V base()&&{return std::move(base_);} constexprauto begin(){ifconstexpr(forward_range<V>){return __outer_iterator<__simple_view<V>&& __simple_view<Pattern>>{*this, ranges::begin(base_)};}else{ current_ =ranges::begin(base_);return __outer_iterator<false>{*this};}} constexprauto begin()const requires forward_range<V>&& forward_range<const V>{return __outer_iterator<true>{*this, ranges::begin(base_)};} constexprauto end() requires forward_range<V>&& common_range<V>{return __outer_iterator<__simple_view<V>&& __simple_view<Pattern>>{*this, ranges::end(base_)};} constexprauto end()const{ifconstexpr(forward_range<V>&& forward_range<const V>&& common_range<const V>)return __outer_iterator<true>{*this, ranges::end(base_)};elsereturn default_sentinel;}}; template<class R, class P> lazy_split_view(R&&, P&&)-> lazy_split_view<views::all_t<R>, views::all_t<P>>; template<input_range R> lazy_split_view(R&&, range_value_t<R>)-> lazy_split_view<views::all_t<R>, single_view<range_value_t<R>>>;}
[править]Шаблон класса std::ranges::lazy_split_view::outer_iterator
namespace std::ranges{template<input_range V, forward_range Pattern> requires view<V>&& view<Pattern>&& indirectly_comparable<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to>&&(forward_range<V>|| __tiny_range<Pattern>)template<bool Const>struct lazy_split_view<V, Pattern>::__outer_iterator {private:using Parent = __maybe_const<Const, lazy_split_view>;// exposition onlyusing Base = __maybe_const<Const, V>;// exposition only Parent* parent_ = nullptr;// exposition only iterator_t<Base> current_ = iterator_t<Base>();// exposition only, present only// if V models forward_range bool trailing_empty_ =false;// exposition only public:using iterator_concept = conditional_t<forward_range<Base>, forward_iterator_tag, input_iterator_tag>; using iterator_category = input_iterator_tag;// present only if Base// models forward_range // class lazy_split_view::outer-iterator::value_typestruct value_type;using difference_type = range_difference_t<Base>; __outer_iterator()=default;constexprexplicit __outer_iterator(Parent& parent) requires (!forward_range<Base>);constexpr __outer_iterator(Parent& parent, iterator_t<Base> current) requires forward_range<Base>;constexpr __outer_iterator(__outer_iterator<!Const> i) requires Const && convertible_to<iterator_t<V>, iterator_t<Base>>; constexpr value_type operator*()const; constexpr __outer_iterator& operator++();constexpr decltype(auto) operator++(int){ifconstexpr(forward_range<Base>){auto tmp =*this;++*this;return tmp;}else++*this;} friendconstexprbool operator==(const __outer_iterator& x, const __outer_iterator& y) requires forward_range<Base>; friendconstexprbool operator==(const __outer_iterator& x, default_sentinel_t);};}
[править]Шаблон класса std::ranges::lazy_split_view::outer_iterator::value_type
namespace std::ranges{template<input_range V, forward_range Pattern> requires view<V>&& view<Pattern>&& indirectly_comparable<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to>&&(forward_range<V>|| __tiny_range<Pattern>)template<bool Const>struct lazy_split_view<V, Pattern>::__outer_iterator<Const>::value_type: view_interface<value_type>{private: __outer_iterator i_ = __outer_iterator();// exposition onlypublic: value_type()=default;constexprexplicit value_type(__outer_iterator i); constexpr __inner_iterator<Const> begin()const;constexpr default_sentinel_t end()constnoexcept;};}
[править]Шаблон класса std::ranges::lazy_split_view::inner_iterator
namespace std::ranges{template<input_range V, forward_range Pattern> requires view<V>&& view<Pattern>&& indirectly_comparable<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to>&&(forward_range<V>|| __tiny_range<Pattern>)template<bool Const>struct lazy_split_view<V, Pattern>::__inner_iterator {private:using Base = __maybe_const<Const, V>;// exposition only __outer_iterator<Const> i_ = __outer_iterator<Const>();// exposition onlybool incremented_ =false;// exposition only public:using iterator_concept =typename __outer_iterator<Const>::iterator_concept; using iterator_category =/* see description */;// present only if Base// models forward_rangeusing value_type = range_value_t<Base>;using difference_type = range_difference_t<Base>; __inner_iterator()=default;constexprexplicit __inner_iterator(__outer_iterator<Const> i); constexprconst iterator_t<Base>& base()const&noexcept;constexpr iterator_t<Base> base()&& requires forward_range<V>; constexpr decltype(auto) operator*()const{return*i_.current;} constexpr __inner_iterator& operator++();constexpr decltype(auto) operator++(int){ifconstexpr(forward_range<Base>){auto tmp =*this;++*this;return tmp;}else++*this;} friendconstexprbool operator==(const __inner_iterator& x, const __inner_iterator& y) requires forward_range<Base>; friendconstexprbool operator==(const __inner_iterator& x, default_sentinel_t); friendconstexpr decltype(auto) iter_move(const __inner_iterator& i)noexcept(noexcept(ranges::iter_move(i.i_.current))){returnranges::iter_move(i.i_.current);} friendconstexprvoid iter_swap(const __inner_iterator& x, const __inner_iterator& y)noexcept(noexcept(ranges::iter_swap(x.i_.current, y.i_.current))) requires indirectly_swappable<iterator_t<Base>>;};}
[править]Шаблон класса std::ranges::split_view
namespace std::ranges{template<forward_range V, forward_range Pattern> requires view<V>&& view<Pattern>&& indirectly_comparable<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to>class split_view :public view_interface<split_view<V, Pattern>>{private: V base_ = V();// exposition only Pattern pattern_ = Pattern();// exposition only // class split_view::iteratorstruct iterator;// exposition only // class split_view::sentinelstruct sentinel;// exposition only public: split_view() requires default_initializable<V>&& default_initializable<Pattern>=default;constexprexplicit split_view(V base, Pattern pattern); template<forward_range R> requires constructible_from<V, views::all_t<R>>&& constructible_from<Pattern, single_view<range_value_t<R>>>constexprexplicit split_view(R&& r, range_value_t<R> e); constexpr V base()const& requires copy_constructible<V>{return base_;}constexpr V base()&&{return std::move(base_);} constexpr iterator begin(); constexprauto end(){ifconstexpr(common_range<V>){return iterator{*this, ranges::end(base_), {}};}else{return sentinel{*this};}} constexpr subrange<iterator_t<V>> __find_next(iterator_t<V>);// exposition only}; template<class R, class P> split_view(R&&, P&&)-> split_view<views::all_t<R>, views::all_t<P>>; template<forward_range R> split_view(R&&, range_value_t<R>)-> split_view<views::all_t<R>, single_view<range_value_t<R>>>;}
[править]Шаблон класса std::ranges::split_view::iterator
namespace std::ranges{template<forward_range V, forward_range Pattern> requires view<V>&& view<Pattern>&& indirectly_comparable<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to>class split_view<V, Pattern>::iterator{private: split_view* parent_ = nullptr;// exposition only iterator_t<V> cur_ = iterator_t<V>();// exposition only subrange<iterator_t<V>> next_ = subrange<iterator_t<V>>();// exposition onlybool trailing_empty_ =false;// exposition only public:using iterator_concept = forward_iterator_tag;using iterator_category = input_iterator_tag;using value_type = subrange<iterator_t<V>>;using difference_type = range_difference_t<V>; iterator()=default;constexpr iterator(split_view& parent, iterator_t<V> current, subrange<iterator_t<V>> next); constexpr iterator_t<V> base()const;constexpr value_type operator*()const; constexpr iterator& operator++();constexpr iterator operator++(int); friendconstexprbool operator==(const iterator& x, const iterator& y);};}
[править]Шаблон класса std::ranges::split_view::sentinel
namespace std::ranges{template<forward_range V, forward_range Pattern> requires view<V>&& view<Pattern>&& indirectly_comparable<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to>struct split_view<V, Pattern>::sentinel{private: sentinel_t<V> end_ = sentinel_t<V>();// exposition only public: sentinel()=default;constexprexplicit sentinel(split_view& parent); friendconstexprbool operator==(const iterator& x, const sentinel& y);};}
[править]Шаблон класса std::ranges::common_view
namespace std::ranges{template<view V> requires (!common_range<V>&& copyable<iterator_t<V>>)class common_view :public view_interface<common_view<V>>{private: V base_ = V();// exposition onlypublic: common_view() requires default_initializable<V>=default; constexprexplicit common_view(V r); constexpr V base()const& requires copy_constructible<V>{return base_;}constexpr V base()&&{return std::move(base_);} constexprauto begin(){ifconstexpr(random_access_range<V>&& sized_range<V>)returnranges::begin(base_);elsereturn common_iterator<iterator_t<V>, sentinel_t<V>>(ranges::begin(base_));} constexprauto begin()const requires range<const V>{ifconstexpr(random_access_range<const V>&& sized_range<const V>)returnranges::begin(base_);elsereturn common_iterator<iterator_t<const V>, sentinel_t<const V>>(ranges::begin(base_));} constexprauto end(){ifconstexpr(random_access_range<V>&& sized_range<V>)returnranges::begin(base_)+ranges::size(base_);elsereturn common_iterator<iterator_t<V>, sentinel_t<V>>(ranges::end(base_));} constexprauto end()const requires range<const V>{ifconstexpr(random_access_range<const V>&& sized_range<const V>)returnranges::begin(base_)+ranges::size(base_);elsereturn common_iterator<iterator_t<const V>, sentinel_t<const V>>(ranges::end(base_));} constexprauto size() requires sized_range<V>{returnranges::size(base_);}constexprauto size()const requires sized_range<const V>{returnranges::size(base_);}}; template<class R> common_view(R&&)-> common_view<views::all_t<R>>;}
[править]Шаблон класса std::ranges::reverse_view
namespace std::ranges{template<view V> requires bidirectional_range<V>class reverse_view :public view_interface<reverse_view<V>>{private: V base_ = V();// exposition onlypublic: reverse_view() requires default_initializable<V>=default; constexprexplicit reverse_view(V r); constexpr V base()const& requires copy_constructible<V>{return base_;}constexpr V base()&&{return std::move(base_);} constexpr reverse_iterator<iterator_t<V>> begin();constexpr reverse_iterator<iterator_t<V>> begin() requires common_range<V>;constexprauto begin()const requires common_range<const V>; constexpr reverse_iterator<iterator_t<V>> end();constexprauto end()const requires common_range<const V>; constexprauto size() requires sized_range<V>{returnranges::size(base_);} constexprauto size()const requires sized_range<const V>{returnranges::size(base_);}}; template<class R> reverse_view(R&&)-> reverse_view<views::all_t<R>>;}
[править]Шаблон класса std::ranges::as_const_view
namespace std::ranges{template<view V> requires input_range<V>class as_const_view :public view_interface<as_const_view<V>>{ V base_ = V();// exposition only public: as_const_view() requires default_initializable<V>=default;constexprexplicit as_const_view(V base); constexpr V base()const& requires copy_constructible<V>{return base_;}constexpr V base()&&{return std::move(base_);} constexprauto begin() requires (!__simple_view<V>){returnranges::cbegin(base_);}constexprauto begin()const requires range<const V>{returnranges::cbegin(base_);} constexprauto end() requires (!__simple_view<V>){returnranges::cend(base_);}constexprauto end()const requires range<const V>{returnranges::cend(base_);} constexprauto size() requires sized_range<V>{returnranges::size(base_);}constexprauto size()const requires sized_range<const V>{returnranges::size(base_);}}; template<class R> as_const_view(R&&)-> as_const_view<views::all_t<R>>;}
[править]Шаблон класса std::ranges::elements_view
namespace std::ranges{template<class T, size_t N> concept __has_tuple_element =// exposition only __tuple_like<T>&& N < tuple_size_v<T>; template<class T, size_t N> concept __returnable_element =// exposition only is_reference_v<T>|| move_constructible<tuple_element_t<N, T>>; template<input_range V, size_t N> requires view<V>&& __has_tuple_element<range_value_t<V>, N>&& __has_tuple_element<remove_reference_t<range_reference_t<V>>, N>&& __returnable_element<range_reference_t<V>, N>class elements_view :public view_interface<elements_view<V, N>>{public: elements_view() requires default_initializable<V>=default;constexprexplicit elements_view(V base); constexpr V base()const& requires copy_constructible<V>{return base_;}constexpr V base()&&{return std::move(base_);} constexprauto begin() requires (!__simple_view<V>){return iterator<false>(ranges::begin(base_));} constexprauto begin()const requires range<const V>{return iterator<true>(ranges::begin(base_));} constexprauto end() requires (!__simple_view<V>&&!common_range<V>){return sentinel<false>{ranges::end(base_)};} constexprauto end() requires (!__simple_view<V>&& common_range<V>){return iterator<false>{ranges::end(base_)};} constexprauto end()const requires range<const V>{return sentinel<true>{ranges::end(base_)};} constexprauto end()const requires common_range<const V>{return iterator<true>{ranges::end(base_)};} constexprauto size() requires sized_range<V>{returnranges::size(base_);} constexprauto size()const requires sized_range<const V>{returnranges::size(base_);} private:// class template elements_view::iteratortemplate<bool>class iterator;// exposition only // class template elements_view::sentineltemplate<bool>class sentinel;// exposition only V base_ = V();// exposition only};}
[править]Шаблон класса std::ranges::elements_view::iterator
namespace std::ranges{template<input_range V, size_t N> requires view<V>&& __has_tuple_element<range_value_t<V>, N>&& __has_tuple_element<remove_reference_t<range_reference_t<V>>, N>&& __returnable_element<range_reference_t<V>, N>template<bool Const>class elements_view<V, N>::iterator{using Base = __maybe_const<Const, V>;// exposition only iterator_t<Base> current_ = iterator_t<Base>();// exposition only staticconstexpr decltype(auto) __get_element(const iterator_t<Base>& i);// exposition only public:using iterator_concept =/* see description */;using iterator_category =/* see description */;// not always presentusing value_type = remove_cvref_t<tuple_element_t<N, range_value_t<Base>>>;using difference_type = range_difference_t<Base>; iterator() requires default_initializable<iterator_t<Base>>=default;constexprexplicit iterator(iterator_t<Base> current);constexpr iterator(iterator<!Const> i) requires Const && convertible_to<iterator_t<V>, iterator_t<Base>>; constexprconst iterator_t<Base>& base()const&noexcept;constexpr iterator_t<Base> base()&&; constexpr decltype(auto) operator*()const{return __get_element(current_);} constexpr iterator& operator++();constexprvoid operator++(int);constexpr iterator operator++(int) requires forward_range<Base>; constexpr iterator& operator--() requires bidirectional_range<Base>;constexpr iterator operator--(int) requires bidirectional_range<Base>; constexpr iterator& operator+=(difference_type x) requires random_access_range<Base>;constexpr iterator& operator-=(difference_type x) requires random_access_range<Base>; constexpr decltype(auto) operator[](difference_type n)const requires random_access_range<Base>{return __get_element(current_ + n);} friendconstexprbool operator==(const iterator& x, const iterator& y) requires equality_comparable<iterator_t<Base>>; friendconstexprbool operator<(const iterator& x, const iterator& y) requires random_access_range<Base>;friendconstexprbool operator>(const iterator& x, const iterator& y) requires random_access_range<Base>;friendconstexprbool operator<=(const iterator& x, const iterator& y) requires random_access_range<Base>;friendconstexprbool operator>=(const iterator& x, const iterator& y) requires random_access_range<Base>;friendconstexprauto operator<=>(const iterator& x, const iterator& y) requires random_access_range<Base>&& three_way_comparable<iterator_t<Base>>; friendconstexpr iterator operator+(const iterator& x, difference_type y) requires random_access_range<Base>;friendconstexpr iterator operator+(difference_type x, const iterator& y) requires random_access_range<Base>;friendconstexpr iterator operator-(const iterator& x, difference_type y) requires random_access_range<Base>;friendconstexpr difference_type operator-(const iterator& x, const iterator& y) requires sized_sentinel_for<iterator_t<Base>, iterator_t<Base>>;};}
[править]Шаблон класса std::ranges::elements_view::sentinel
namespace std::ranges{template<input_range V, size_t N> requires view<V>&& __has_tuple_element<range_value_t<V>, N>&& __has_tuple_element<remove_reference_t<range_reference_t<V>>, N>&& __returnable_element<range_reference_t<V>, N>template<bool Const>class elements_view<V, N>::sentinel{private:using Base = __maybe_const<Const, V>;// exposition only sentinel_t<Base> end_ = sentinel_t<Base>();// exposition onlypublic: sentinel()=default;constexprexplicit sentinel(sentinel_t<Base> end);constexpr sentinel(sentinel<!Const> other) requires Const && convertible_to<sentinel_t<V>, sentinel_t<Base>>; constexpr sentinel_t<Base> base()const; template<bool OtherConst> requires sentinel_for<sentinel_t<Base>, iterator_t<__maybe_const<OtherConst, V>>>friendconstexprbool operator==(const iterator<OtherConst>& x, const sentinel& y); template<bool OtherConst> requires sized_sentinel_for<sentinel_t<Base>, iterator_t<__maybe_const<OtherConst, V>>>friendconstexpr range_difference_t<__maybe_const<OtherConst, V>> operator-(const iterator<OtherConst>& x, const sentinel& y); template<bool OtherConst> requires sized_sentinel_for<sentinel_t<Base>, iterator_t<__maybe_const<OtherConst, V>>>friendconstexpr range_difference_t<__maybe_const<OtherConst, V>> operator-(const sentinel& x, const iterator<OtherConst>& y);};}
[править]Шаблон класса std::ranges::enumerate_view
template<view V> requires __range_with_movable_references<V>class enumerate_view :public view_interface<enumerate_view<V>>{ V base_ = V();// exposition onlytemplate<bool Const>class iterator;// exposition onlytemplate<bool Const>class sentinel;// exposition onlypublic:constexpr enumerate_view() requires default_initializable<V>=default;constexprexplicit enumerate_view(V base);constexprauto begin() requires(!__simple_view<V>){return iterator<false>(ranges::begin(base_), 0);}constexprauto begin()const requires __range_with_movable_references<const V>{return iterator<true>(ranges::begin(base_), 0);}constexprauto end() requires(!__simple_view<V>){ifconstexpr(common_range<V>&& sized_range<V>)return iterator<false>(ranges::end(base_), ranges::distance(base_));elsereturn sentinel<false>(ranges::end(base_));}constexprauto end()const requires __range_with_movable_references<const V>{ifconstexpr(common_range<const V>&& sized_range<const V>)return iterator<true>(ranges::end(base_), ranges::distance(base_));elsereturn sentinel<true>(ranges::end(base_));}constexprauto size() requires sized_range<V>{returnranges::size(base_);}constexprauto size()const requires sized_range<const V>{returnranges::size(base_);}constexpr V base()const& requires copy_constructible<V>{return base_;}constexpr V base()&&{return std::move(base_);}};template<class R> enumerate_view(R&&)-> enumerate_view<views::all_t<R>>;}
[править]Шаблон класса std::ranges::enumerate_view::iterator
namespace std::ranges{template<view V> requires __range_with_movable_references<V>template<bool Const>class enumerate_view<V>::iterator{using Base = __maybe_const<Const, V>;// exposition onlypublic:using iterator_category = input_iterator_tag;using iterator_concept =/* see description */;using difference_type = range_difference_t<Base>;using value_type = tuple<difference_type, range_value_t<Base>>; private:using __reference_type =// exposition only tuple<difference_type, range_reference_t<Base>>; iterator_t<Base> current_ = iterator_t<Base>();// exposition only difference_type pos_ =0;// exposition onlyconstexprexplicit iterator(iterator_t<Base> current, difference_type pos);// exposition onlypublic: iterator() requires default_initializable<iterator_t<Base>>=default;constexpr iterator(iterator<!Const> i) requires Const && convertible_to<iterator_t<V>, iterator_t<Base>>;constexprconst iterator_t<Base>& base()const&noexcept;constexpr iterator_t<Base> base()&&;constexpr difference_type index()constnoexcept;constexprauto operator*()const{return __reference_type(pos_, *current_);}constexpr iterator& operator++();constexprvoid operator++(int);constexpr iterator operator++(int) requires forward_range<Base>;constexpr iterator& operator--() requires bidirectional_range<Base>;constexpr iterator operator--(int) requires bidirectional_range<Base>;constexpr iterator& operator+=(difference_type x) requires random_access_range<Base>;constexpr iterator& operator-=(difference_type x) requires random_access_range<Base>;constexprauto operator[](difference_type n)const requires random_access_range<Base>{return __reference_type(pos_ + n, current_[n]);}friendconstexprbool operator==(const iterator& x, const iterator& y)noexcept;friendconstexpr strong_ordering operator<=>(const iterator& x, const iterator& y)noexcept;friendconstexpr iterator operator+(const iterator& x, difference_type y) requires random_access_range<Base>;friendconstexpr iterator operator+(difference_type x, const iterator& y) requires random_access_range<Base>;friendconstexpr iterator operator-(const iterator& x, difference_type y) requires random_access_range<Base>;friendconstexpr difference_type operator-(const iterator& x, const iterator& y)noexcept;friendconstexprauto iter_move(const iterator& i)noexcept(noexcept(ranges::iter_move(i.current_))&& is_nothrow_move_constructible_v<range_rvalue_reference_t<Base>>){return tuple<difference_type, range_rvalue_reference_t<Base>>( pos_, ranges::iter_move(i.current_));}};}
[править]Шаблон класса std::ranges::enumerate_view::sentinel
namespace std::ranges{template<view V> requires __range_with_movable_references<V>template<bool Const>class enumerate_view<V>::sentinel{// exposition onlyusing Base = __maybe_const<Const, V>;// exposition only sentinel_t<Base> end_ = sentinel_t<Base>();// exposition onlyconstexprexplicit sentinel(sentinel_t<Base> end); public: sentinel()=default;constexpr sentinel(sentinel<!Const> other) requires Const && convertible_to<sentinel_t<V>, sentinel_t<Base>>;constexpr sentinel_t<Base> base()const;template<bool OtherConst> requires sentinel_for<sentinel_t<Base>, iterator_t<__maybe_const<OtherConst, V>>>friendconstexprbool operator==(const iterator<OtherConst>& x, const sentinel& y);template<bool OtherConst> requires sized_sentinel_for<sentinel_t<Base>, iterator_t<__maybe_const<OtherConst, V>>>friendconstexpr range_difference_t<__maybe_const<OtherConst, V>> operator-(const iterator<OtherConst>& x, const sentinel& y);template<bool OtherConst> requires sized_sentinel_for<sentinel_t<Base>, iterator_t<__maybe_const<OtherConst, V>>>friendconstexpr range_difference_t<__maybe_const<OtherConst, V>> operator-(const sentinel& x, const iterator<OtherConst>& y);};}
[править]Шаблон класса std::ranges::zip_view
namespace std::ranges{template<class... Rs> concept __zip_is_common =// exposition only(sizeof...(Rs)==1&&(common_range<Rs>&& ...))||(!(bidirectional_range<Rs>&& ...)&&(common_range<Rs>&& ...))||((random_access_range<Rs>&& ...)&&(sized_range<Rs>&& ...)); template<input_range... Views> requires (view<Views>&& ...)&&(sizeof...(Views)>0)class zip_view :public view_interface<zip_view<Views...>>{ tuple<Views...> views_;// exposition only // class template zip_view::iteratortemplate<bool>class iterator;// exposition only // class template zip_view::sentineltemplate<bool>class sentinel;// exposition only public: zip_view()=default;constexprexplicit zip_view(Views... views); constexprauto begin() requires (!(__simple_view<Views>&& ...)){return iterator<false>(__tuple_transform(ranges::begin, views_));}constexprauto begin()const requires (range<const Views>&& ...){return iterator<true>(__tuple_transform(ranges::begin, views_));} constexprauto end() requires (!(__simple_view<Views>&& ...)){ifconstexpr(!__zip_is_common<Views...>){return sentinel<false>(__tuple_transform(ranges::end, views_));}elseifconstexpr((random_access_range<Views>&& ...)){return begin()+ iter_difference_t<iterator<false>>(size());}else{return iterator<false>(__tuple_transform(ranges::end, views_));}} constexprauto end()const requires (range<const Views>&& ...){ifconstexpr(!__zip_is_common<const Views...>){return sentinel<true>(__tuple_transform(ranges::end, views_));}elseifconstexpr((random_access_range<const Views>&& ...)){return begin()+ iter_difference_t<iterator<true>>(size());}else{return iterator<true>(__tuple_transform(ranges::end, views_));}} constexprauto size() requires (sized_range<Views>&& ...);constexprauto size()const requires (sized_range<const Views>&& ...);}; template<class... Rs> zip_view(Rs&&...)-> zip_view<views::all_t<Rs>...>;}
[править]Шаблон класса std::ranges::zip_view::iterator
namespace std::ranges{template<bool Const, class... Views> concept __all_random_access =// exposition only(random_access_range<__maybe_const<Const, Views>>&& ...);template<bool Const, class... Views> concept __all_bidirectional =// exposition only(bidirectional_range<__maybe_const<Const, Views>>&& ...);template<bool Const, class... Views> concept __all_forward =// exposition only(forward_range<__maybe_const<Const, Views>>&& ...); template<input_range... Views> requires (view<Views>&& ...)&&(sizeof...(Views)>0)template<bool Const>class zip_view<Views...>::iterator{ tuple<iterator_t<__maybe_const<Const, Views>>...> current_;// exposition onlyconstexprexplicit iterator(tuple<iterator_t<__maybe_const<Const, Views>>...>);// exposition onlypublic:using iterator_category = input_iterator_tag;// not always presentusing iterator_concept =/* see description */;using value_type = tuple<range_value_t<__maybe_const<Const, Views>>...>;using difference_type = common_type_t<range_difference_t< __maybe_const<Const, Views>>...>; iterator()=default;constexpr iterator(iterator<!Const> i) requires Const &&(convertible_to<iterator_t<Views>, iterator_t<const Views>>&& ...); constexprauto operator*()const;constexpr iterator& operator++();constexprvoid operator++(int);constexpr iterator operator++(int) requires __all_forward<Const, Views...>; constexpr iterator& operator--() requires __all_bidirectional<Const, Views...>;constexpr iterator operator--(int) requires __all_bidirectional<Const, Views...>; constexpr iterator& operator+=(difference_type x) requires __all_random_access<Const, Views...>;constexpr iterator& operator-=(difference_type x) requires __all_random_access<Const, Views...>; constexprauto operator[](difference_type n)const requires __all_random_access<Const, Views...>; friendconstexprbool operator==(const iterator& x, const iterator& y) requires (equality_comparable<iterator_t<__maybe_const<Const, Views>>>&& ...); friendconstexprauto operator<=>(const iterator& x, const iterator& y) requires __all_random_access<Const, Views...>; friendconstexpr iterator operator+(const iterator& i, difference_type n) requires __all_random_access<Const, Views...>;friendconstexpr iterator operator+(difference_type n, const iterator& i) requires __all_random_access<Const, Views...>;friendconstexpr iterator operator-(const iterator& i, difference_type n) requires __all_random_access<Const, Views...>;friendconstexpr difference_type operator-(const iterator& x, const iterator& y) requires (sized_sentinel_for<iterator_t<__maybe_const<Const, Views>>, iterator_t<__maybe_const<Const, Views>>>&& ...); friendconstexprauto iter_move(const iterator& i)noexcept(/* see description */); friendconstexprvoid iter_swap(const iterator& l, const iterator& r)noexcept(/* see description */) requires (indirectly_swappable<iterator_t<__maybe_const<Const, Views>>>&& ...);};}
[править]Шаблон класса std::ranges::zip_view::sentinel
namespace std::ranges{template<input_range... Views> requires (view<Views>&& ...)&&(sizeof...(Views)>0)template<bool Const>class zip_view<Views...>::sentinel{ tuple<sentinel_t<__maybe_const<Const, Views>>...> end_;// exposition onlyconstexprexplicit sentinel(tuple<sentinel_t<__maybe_const<Const, Views>>...> end);// exposition onlypublic: sentinel()=default;constexpr sentinel(sentinel<!Const> i) requires Const &&(convertible_to<sentinel_t<Views>, sentinel_t<const Views>>&& ...); template<bool OtherConst> requires (sentinel_for<sentinel_t<__maybe_const<Const, Views>>, iterator_t<__maybe_const<OtherConst, Views>>>&& ...)friendconstexprbool operator==(const iterator<OtherConst>& x, const sentinel& y); template<bool OtherConst> requires (sized_sentinel_for<sentinel_t<__maybe_const<Const, Views>>, iterator_t<__maybe_const<OtherConst, Views>>>&& ...)friendconstexpr common_type_t<range_difference_t<__maybe_const<OtherConst, Views>>...> operator-(const iterator<OtherConst>& x, const sentinel& y); template<bool OtherConst> requires (sized_sentinel_for<sentinel_t<__maybe_const<Const, Views>>, iterator_t<__maybe_const<OtherConst, Views>>>&& ...)friendconstexpr common_type_t<range_difference_t<__maybe_const<OtherConst, Views>>...> operator-(const sentinel& y, const iterator<OtherConst>& x);};}
[править]Шаблон класса std::ranges::zip_transform_view
namespace std::ranges{template<move_constructible F, input_range... Views> requires (view<Views>&& ...)&&(sizeof...(Views)>0)&& is_object_v<F>&& regular_invocable<F&, range_reference_t<Views>...>&& __can_reference<invoke_result_t<F&, range_reference_t<Views>...>>class zip_transform_view :public view_interface<zip_transform_view<F, Views...>>{ __movable_box<F> fun_;// exposition only zip_view<Views...> zip_;// exposition only using InnerView = zip_view<Views...>;// exposition onlytemplate<bool Const>using ziperator = iterator_t<__maybe_const<Const, InnerView>>;// exposition onlytemplate<bool Const>using zentinel = sentinel_t<__maybe_const<Const, InnerView>>;// exposition only // class template zip_transform_view::iteratortemplate<bool>class iterator;// exposition only // class template zip_transform_view::sentineltemplate<bool>class sentinel;// exposition only public: zip_transform_view()=default; constexprexplicit zip_transform_view(F fun, Views... views); constexprauto begin(){return iterator<false>(*this, zip_.begin());} constexprauto begin()const requires range<const InnerView>&& regular_invocable<const F&, range_reference_t<const Views>...>{return iterator<true>(*this, zip_.begin());} constexprauto end(){ifconstexpr(common_range<InnerView>){return iterator<false>(*this, zip_.end());}else{return sentinel<false>(zip_.end());}} constexprauto end()const requires range<const InnerView>&& regular_invocable<const F&, range_reference_t<const Views>...>{ifconstexpr(common_range<const InnerView>){return iterator<true>(*this, zip_.end());}else{return sentinel<true>(zip_.end());}} constexprauto size() requires sized_range<InnerView>{return zip_.size();} constexprauto size()const requires sized_range<const InnerView>{return zip_.size();}}; template<class F, class... Rs> zip_transform_view(F, Rs&&...)-> zip_transform_view<F, views::all_t<Rs>...>;}
[править]Шаблон класса std::ranges::zip_transform_view::iterator
namespace std::ranges{template<move_constructible F, input_range... Views> requires (view<Views>&& ...)&&(sizeof...(Views)>0)&& is_object_v<F>&& regular_invocable<F&, range_reference_t<Views>...>&& __can_reference<invoke_result_t<F&, range_reference_t<Views>...>>template<bool Const>class zip_transform_view<F, Views...>::iterator{using Parent = __maybe_const<Const, zip_transform_view>;// exposition onlyusing Base = __maybe_const<Const, InnerView>;// exposition only Parent* parent_ = nullptr;// exposition only ziperator<Const> inner_;// exposition only constexpr iterator(Parent& parent, ziperator<Const> inner);// exposition only public:using iterator_category =/* see description */;// not always presentusing iterator_concept =typename ziperator<Const>::iterator_concept;using value_type = remove_cvref_t<invoke_result_t<__maybe_const<Const, F>&, range_reference_t<__maybe_const<Const, Views>>...>>;using difference_type = range_difference_t<Base>; iterator()=default;constexpr iterator(iterator<!Const> i) requires Const && convertible_to<ziperator<false>, ziperator<Const>>; constexpr decltype(auto) operator*()constnoexcept(/* see description */);constexpr iterator& operator++();constexprvoid operator++(int);constexpr iterator operator++(int) requires forward_range<Base>; constexpr iterator& operator--() requires bidirectional_range<Base>;constexpr iterator operator--(int) requires bidirectional_range<Base>; constexpr iterator& operator+=(difference_type x) requires random_access_range<Base>;constexpr iterator& operator-=(difference_type x) requires random_access_range<Base>; constexpr decltype(auto) operator[](difference_type n)const requires random_access_range<Base>; friendconstexprbool operator==(const iterator& x, const iterator& y) requires equality_comparable<ziperator<Const>>; friendconstexprauto operator<=>(const iterator& x, const iterator& y) requires random_access_range<Base>; friendconstexpr iterator operator+(const iterator& i, difference_type n) requires random_access_range<Base>;friendconstexpr iterator operator+(difference_type n, const iterator& i) requires random_access_range<Base>;friendconstexpr iterator operator-(const iterator& i, difference_type n) requires random_access_range<Base>;friendconstexpr difference_type operator-(const iterator& x, const iterator& y) requires sized_sentinel_for<ziperator<Const>, ziperator<Const>>;};}
[править]Шаблон класса std::ranges::zip_transform_view::sentinel
namespace std::ranges{template<move_constructible F, input_range... Views> requires (view<Views>&& ...)&&(sizeof...(Views)>0)&& is_object_v<F>&& regular_invocable<F&, range_reference_t<Views>...>&& __can_reference<invoke_result_t<F&, range_reference_t<Views>...>>template<bool Const>class zip_transform_view<F, Views...>::sentinel{ zentinel<Const> inner_;// exposition onlyconstexprexplicit sentinel(zentinel<Const> inner);// exposition only public: sentinel()=default;constexpr sentinel(sentinel<!Const> i) requires Const && convertible_to<zentinel<false>, zentinel<Const>>; template<bool OtherConst> requires sentinel_for<zentinel<Const>, ziperator<OtherConst>>friendconstexprbool operator==(const iterator<OtherConst>& x, const sentinel& y); template<bool OtherConst> requires sized_sentinel_for<zentinel<Const>, ziperator<OtherConst>>friendconstexpr range_difference_t<__maybe_const<OtherConst, InnerView>> operator-(const iterator<OtherConst>& x, const sentinel& y); template<bool OtherConst> requires sized_sentinel_for<zentinel<Const>, ziperator<OtherConst>>friendconstexpr range_difference_t<__maybe_const<OtherConst, InnerView>> operator-(const sentinel& x, const iterator<OtherConst>& y);};}
[править]Шаблон класса std::ranges::adjacent_view
namespace std::ranges{template<forward_range V, size_t N> requires view<V>&&(N >0)class adjacent_view :public view_interface<adjacent_view<V, N>>{ V base_ = V();// exposition only // class template adjacent_view::iteratortemplate<bool>class iterator;// exposition only // class template adjacent_view::sentineltemplate<bool>class sentinel;// exposition only struct __as_sentinel{};// exposition only public: adjacent_view() requires default_initializable<V>=default;constexprexplicit adjacent_view(V base); constexprauto begin() requires (!__simple_view<V>){return iterator<false>(ranges::begin(base_), ranges::end(base_));} constexprauto begin()const requires range<const V>{return iterator<true>(ranges::begin(base_), ranges::end(base_));} constexprauto end() requires (!__simple_view<V>){ifconstexpr(common_range<V>){return iterator<false>(__as_sentinel{}, ranges::begin(base_), ranges::end(base_));}else{return sentinel<false>(ranges::end(base_));}} constexprauto end()const requires range<const V>{ifconstexpr(common_range<const V>){return iterator<true>(__as_sentinel{}, ranges::begin(base_), ranges::end(base_));}else{return sentinel<true>(ranges::end(base_));}} constexprauto size() requires sized_range<V>;constexprauto size()const requires sized_range<const V>;};}
[править]Шаблон класса std::ranges::adjacent_view::iterator
namespace std::ranges{template<forward_range V, size_t N> requires view<V>&&(N >0)template<bool Const>class adjacent_view<V, N>::iterator{using Base = __maybe_const<Const, V>;// exposition only array<iterator_t<Base>, N> current_ = array<iterator_t<Base>, N>();// exposition onlyconstexpr iterator(iterator_t<Base> first, sentinel_t<Base> last);// exposition onlyconstexpr iterator(__as_sentinel, iterator_t<Base> first, iterator_t<Base> last);// exposition onlypublic:using iterator_category = input_iterator_tag;using iterator_concept =/* see description */;using value_type = tuple<__REPEAT(range_value_t<Base>, N)...>;using difference_type = range_difference_t<Base>; iterator()=default;constexpr iterator(iterator<!Const> i) requires Const && convertible_to<iterator_t<V>, iterator_t<Base>>; constexprauto operator*()const;constexpr iterator& operator++();constexpr iterator operator++(int); constexpr iterator& operator--() requires bidirectional_range<Base>;constexpr iterator operator--(int) requires bidirectional_range<Base>; constexpr iterator& operator+=(difference_type x) requires random_access_range<Base>;constexpr iterator& operator-=(difference_type x) requires random_access_range<Base>; constexprauto operator[](difference_type n)const requires random_access_range<Base>; friendconstexprbool operator==(const iterator& x, const iterator& y);friendconstexprbool operator<(const iterator& x, const iterator& y) requires random_access_range<Base>;friendconstexprbool operator>(const iterator& x, const iterator& y) requires random_access_range<Base>;friendconstexprbool operator<=(const iterator& x, const iterator& y) requires random_access_range<Base>;friendconstexprbool operator>=(const iterator& x, const iterator& y) requires random_access_range<Base>;friendconstexprauto operator<=>(const iterator& x, const iterator& y) requires random_access_range<Base>&& three_way_comparable<iterator_t<Base>>; friendconstexpr iterator operator+(const iterator& i, difference_type n) requires random_access_range<Base>;friendconstexpr iterator operator+(difference_type n, const iterator& i) requires random_access_range<Base>;friendconstexpr iterator operator-(const iterator& i, difference_type n) requires random_access_range<Base>;friendconstexpr difference_type operator-(const iterator& x, const iterator& y) requires sized_sentinel_for<iterator_t<Base>, iterator_t<Base>>; friendconstexprauto iter_move(const iterator& i)noexcept(/* see description */);friendconstexprvoid iter_swap(const iterator& l, const iterator& r)noexcept(/* see description */) requires indirectly_swappable<iterator_t<Base>>;};}
[править]Шаблон класса std::ranges::adjacent_view::sentinel
namespace std::ranges{template<forward_range V, size_t N> requires view<V>&&(N >0)template<bool Const>class adjacent_view<V, N>::sentinel{using Base = __maybe_const<Const, V>;// exposition only sentinel_t<Base> end_ = sentinel_t<Base>();// exposition onlyconstexprexplicit sentinel(sentinel_t<Base> end);// exposition only public: sentinel()=default;constexpr sentinel(sentinel<!Const> i) requires Const && convertible_to<sentinel_t<V>, sentinel_t<Base>>; template<bool OtherConst> requires sentinel_for<sentinel_t<Base>, iterator_t<__maybe_const<OtherConst, V>>>friendconstexprbool operator==(const iterator<OtherConst>& x, const sentinel& y); template<bool OtherConst> requires sized_sentinel_for<sentinel_t<Base>, iterator_t<__maybe_const<OtherConst, V>>>friendconstexpr range_difference_t<__maybe_const<OtherConst, V>> operator-(const iterator<OtherConst>& x, const sentinel& y); template<bool OtherConst> requires sized_sentinel_for<sentinel_t<Base>, iterator_t<__maybe_const<OtherConst, V>>>friendconstexpr range_difference_t<__maybe_const<OtherConst, V>> operator-(const sentinel& y, const iterator<OtherConst>& x);};}
[править]Шаблон класса std::ranges::adjacent_transform_view
namespace std::ranges{template<forward_range V, move_constructible F, size_t N> requires view<V>&&(N >0)&& is_object_v<F>&& regular_invocable<F&, __REPEAT(range_reference_t<V>, N)...>&& __can_reference<invoke_result_t<F&, __REPEAT(range_reference_t<V>, N)...>>class adjacent_transform_view :public view_interface<adjacent_transform_view<V, F, N>>{ __movable_box<F> fun_;// exposition only adjacent_view<V, N> inner_;// exposition only using InnerView = adjacent_view<V, N>;// exposition onlytemplate<bool Const>using __inner_iterator = iterator_t<__maybe_const<Const, InnerView>>;// exposition onlytemplate<bool Const>using __inner_sentinel = sentinel_t<__maybe_const<Const, InnerView>>;// exposition only // class template adjacent_transform_view::iteratortemplate<bool>class iterator;// exposition only // class template adjacent_transform_view::sentineltemplate<bool>class sentinel;// exposition only public: adjacent_transform_view()=default;constexprexplicit adjacent_transform_view(V base, F fun); constexprauto begin(){return iterator<false>(*this, inner_.begin());} constexprauto begin()const requires range<const InnerView>&& regular_invocable<const F&, __REPEAT(range_reference_t<const V>, N)...>{return iterator<true>(*this, inner_.begin());} constexprauto end(){ifconstexpr(common_range<InnerView>){return iterator<false>(*this, inner_.end());}else{return sentinel<false>(inner_.end());}} constexprauto end()const requires range<const InnerView>&& regular_invocable<const F&, __REPEAT(range_reference_t<const V>, N)...>{ifconstexpr(common_range<const InnerView>){return iterator<true>(*this, inner_.end());}else{return sentinel<true>(inner_.end());}} constexprauto size() requires sized_range<InnerView>{return inner_.size();} constexprauto size()const requires sized_range<const InnerView>{return inner_.size();}};}
[править]Шаблон класса std::ranges::adjacent_transform_view::iterator
namespace std::ranges{template<forward_range V, move_constructible F, size_t N> requires view<V>&&(N >0)&& is_object_v<F>&& regular_invocable<F&, __REPEAT(range_reference_t<V>, N)...>&& __can_reference<invoke_result_t<F&, __REPEAT(range_reference_t<V>, N)...>>template<bool Const>class adjacent_transform_view<V, F, N>::iterator{using Parent = __maybe_const<Const, adjacent_transform_view>;// exposition onlyusing Base = __maybe_const<Const, V>;// exposition only Parent* parent_ = nullptr;// exposition only __inner_iterator<Const> inner_;// exposition only constexpr iterator(Parent& parent, __inner_iterator<Const> inner);// exposition only public:using iterator_category =/* see description */;using iterator_concept =typename __inner_iterator<Const>::iterator_concept;using value_type = remove_cvref_t<invoke_result_t<__maybe_const<Const, F>&, __REPEAT(range_reference_t<Base>, N)...>>;using difference_type = range_difference_t<Base>; iterator()=default;constexpr iterator(iterator<!Const> i) requires Const && convertible_to<__inner_iterator<false>, __inner_iterator<Const>>; constexpr decltype(auto) operator*()constnoexcept(/* see description */);constexpr iterator& operator++();constexpr iterator operator++(int);constexpr iterator& operator--() requires bidirectional_range<Base>;constexpr iterator operator--(int) requires bidirectional_range<Base>;constexpr iterator& operator+=(difference_type x) requires random_access_range<Base>;constexpr iterator& operator-=(difference_type x) requires random_access_range<Base>; constexpr decltype(auto) operator[](difference_type n)const requires random_access_range<Base>; friendconstexprbool operator==(const iterator& x, const iterator& y);friendconstexprbool operator<(const iterator& x, const iterator& y) requires random_access_range<Base>;friendconstexprbool operator>(const iterator& x, const iterator& y) requires random_access_range<Base>;friendconstexprbool operator<=(const iterator& x, const iterator& y) requires random_access_range<Base>;friendconstexprbool operator>=(const iterator& x, const iterator& y) requires random_access_range<Base>;friendconstexprauto operator<=>(const iterator& x, const iterator& y) requires random_access_range<Base>&& three_way_comparable<__inner_iterator<Const>>; friendconstexpr iterator operator+(const iterator& i, difference_type n) requires random_access_range<Base>;friendconstexpr iterator operator+(difference_type n, const iterator& i) requires random_access_range<Base>;friendconstexpr iterator operator-(const iterator& i, difference_type n) requires random_access_range<Base>;friendconstexpr difference_type operator-(const iterator& x, const iterator& y) requires sized_sentinel_for<__inner_iterator<Const>, __inner_iterator<Const>>;};}
[править]Шаблон класса std::ranges::adjacent_transform_view::sentinel
namespace std::ranges{template<forward_range V, move_constructible F, size_t N> requires view<V>&&(N >0)&& is_object_v<F>&& regular_invocable<F&, __REPEAT(range_reference_t<V>, N)...>&& __can_reference<invoke_result_t<F&, __REPEAT(range_reference_t<V>, N)...>>template<bool Const>class adjacent_transform_view<V, F, N>::sentinel{ __inner_sentinel<Const> inner_;// exposition onlyconstexprexplicit sentinel(__inner_sentinel<Const> inner);// exposition only public: sentinel()=default;constexpr sentinel(sentinel<!Const> i) requires Const && convertible_to<__inner_sentinel<false>, __inner_sentinel<Const>>; template<bool OtherConst> requires sentinel_for<__inner_sentinel<Const>, __inner_iterator<OtherConst>>friendconstexprbool operator==(const iterator<OtherConst>& x, const sentinel& y); template<bool OtherConst> requires sized_sentinel_for<__inner_sentinel<Const>, __inner_iterator<OtherConst>>friendconstexpr range_difference_t<__maybe_const<OtherConst, InnerView>> operator-(const iterator<OtherConst>& x, const sentinel& y); template<bool OtherConst> requires sized_sentinel_for<__inner_sentinel<Const>, __inner_iterator<OtherConst>>friendconstexpr range_difference_t<__maybe_const<OtherConst, InnerView>> operator-(const sentinel& x, const iterator<OtherConst>& y);};}
[править]Шаблон класса std::ranges::chunk_view для input_ranges
namespace std::ranges{template<class I>constexpr I __div_ceil(I num, I denom){// exposition only I r = num / denom;if(num % denom)++r;return r;} template<view V> requires input_range<V>class chunk_view :public view_interface<chunk_view<V>>{ V base_;// exposition only range_difference_t<V> n_;// exposition only range_difference_t<V> remainder_ =0;// exposition only __non_propagating_cache<iterator_t<V>> current_;// exposition only // class chunk_view::outer-iteratorclass __outer_iterator;// exposition only // class chunk_view::inner-iteratorclass __inner_iterator;// exposition only public:constexprexplicit chunk_view(V base, range_difference_t<V> n); constexpr V base()const& requires copy_constructible<V>{return base_;}constexpr V base()&&{return std::move(base_);} constexpr __outer_iterator begin();constexpr default_sentinel_t end()constnoexcept; constexprauto size() requires sized_range<V>;constexprauto size()const requires sized_range<const V>;}; template<class R> chunk_view(R&&, range_difference_t<R>)-> chunk_view<views::all_t<R>>;}
[править]Шаблон класса std::ranges::chunk_view::outer_iterator для input_ranges
namespace std::ranges{template<view V> requires input_range<V>class chunk_view<V>::__outer_iterator { chunk_view* parent_;// exposition only constexprexplicit __outer_iterator(chunk_view& parent);// exposition only public:using iterator_concept = input_iterator_tag;using difference_type = range_difference_t<V>; // class chunk_view::outer-iterator::value_typestruct value_type; __outer_iterator(__outer_iterator&&)=default; __outer_iterator& operator=(__outer_iterator&&)=default; constexpr value_type operator*()const;constexpr __outer_iterator& operator++();constexprvoid operator++(int); friendconstexprbool operator==(const __outer_iterator& x, default_sentinel_t); friendconstexpr difference_type operator-(default_sentinel_t y, const __outer_iterator& x) requires sized_sentinel_for<sentinel_t<V>, iterator_t<V>>;friendconstexpr difference_type operator-(const __outer_iterator& x, default_sentinel_t y) requires sized_sentinel_for<sentinel_t<V>, iterator_t<V>>;};}
[править]Шаблон класса std::ranges::chunk_view::outer_iterator::value_type для input_ranges
namespace std::ranges{template<view V> requires input_range<V>struct chunk_view<V>::__outer_iterator::value_type: view_interface<value_type>{private: chunk_view* parent_;// exposition only constexprexplicit value_type(chunk_view& parent);// exposition only public:constexpr __inner_iterator begin()constnoexcept;constexpr default_sentinel_t end()constnoexcept; constexprauto size()const requires sized_sentinel_for<sentinel_t<V>, iterator_t<V>>;};}
[править]Шаблон класса std::ranges::chunk_view::inner_iterator для input_ranges
namespace std::ranges{template<view V> requires input_range<V>class chunk_view<V>::__inner_iterator { chunk_view* parent_;// exposition only constexprexplicit __inner_iterator(chunk_view& parent)noexcept;// exposition only public:using iterator_concept = input_iterator_tag;using difference_type = range_difference_t<V>;using value_type = range_value_t<V>; __inner_iterator(__inner_iterator&&)=default; __inner_iterator& operator=(__inner_iterator&&)=default; constexprconst iterator_t<V>& base()const&; constexpr range_reference_t<V> operator*()const;constexpr __inner_iterator& operator++();constexprvoid operator++(int); friendconstexprbool operator==(const __inner_iterator& x, default_sentinel_t); friendconstexpr difference_type operator-(default_sentinel_t y, const __inner_iterator& x) requires sized_sentinel_for<sentinel_t<V>, iterator_t<V>>;friendconstexpr difference_type operator-(const __inner_iterator& x, default_sentinel_t y) requires sized_sentinel_for<sentinel_t<V>, iterator_t<V>>;};}
[править]Шаблон класса std::ranges::chunk_view для forward_ranges
namespace std::ranges{template<view V> requires forward_range<V>class chunk_view<V>:public view_interface<chunk_view<V>>{ V base_;// exposition only range_difference_t<V> n_;// exposition only // class template chunk_view::iteratortemplate<bool>class iterator;// exposition only public:constexprexplicit chunk_view(V base, range_difference_t<V> n); constexpr V base()const& requires copy_constructible<V>{return base_;}constexpr V base()&&{return std::move(base_);} constexprauto begin() requires (!__simple_view<V>){return iterator<false>(this, ranges::begin(base_));} constexprauto begin()const requires forward_range<const V>{return iterator<true>(this, ranges::begin(base_));} constexprauto end() requires (!__simple_view<V>){ifconstexpr(common_range<V>&& sized_range<V>){auto missing =(n_ -ranges::distance(base_)% n_)% n_;return iterator<false>(this, ranges::end(base_), missing);}elseifconstexpr(common_range<V>&&!bidirectional_range<V>){return iterator<false>(this, ranges::end(base_));}else{return default_sentinel;}} constexprauto end()const requires forward_range<const V>{ifconstexpr(common_range<const V>&& sized_range<const V>){auto missing =(n_ -ranges::distance(base_)% n_)% n_;return iterator<true>(this, ranges::end(base_), missing);}elseifconstexpr(common_range<const V>&&!bidirectional_range<const V>){return iterator<true>(this, ranges::end(base_));}else{return default_sentinel;}} constexprauto size() requires sized_range<V>;constexprauto size()const requires sized_range<const V>;};}
[править]Шаблон класса std::ranges::chunk_view::iterator для forward_ranges
namespace std::ranges{template<view V> requires forward_range<V>template<bool Const>class chunk_view<V>::iterator{using Parent = __maybe_const<Const, chunk_view>;// exposition onlyusing Base = __maybe_const<Const, V>;// exposition only iterator_t<Base> current_ = iterator_t<Base>();// exposition only sentinel_t<Base> end_ = sentinel_t<Base>();// exposition only range_difference_t<Base> n_ =0;// exposition only range_difference_t<Base> missing_ =0;// exposition only constexpr iterator(Parent* parent, iterator_t<Base> current, // exposition only range_difference_t<Base> missing =0); public:using iterator_category = input_iterator_tag;using iterator_concept =/* see description */;using value_type = decltype(views::take(subrange(current_, end_), n_));using difference_type = range_difference_t<Base>; iterator()=default;constexpr iterator(iterator<!Const> i) requires Const && convertible_to<iterator_t<V>, iterator_t<Base>>&& convertible_to<sentinel_t<V>, sentinel_t<Base>>; constexpr iterator_t<Base> base()const; constexpr value_type operator*()const;constexpr iterator& operator++();constexpr iterator operator++(int); constexpr iterator& operator--() requires bidirectional_range<Base>;constexpr iterator operator--(int) requires bidirectional_range<Base>; constexpr iterator& operator+=(difference_type x) requires random_access_range<Base>;constexpr iterator& operator-=(difference_type x) requires random_access_range<Base>; constexpr value_type operator[](difference_type n)const requires random_access_range<Base>; friendconstexprbool operator==(const iterator& x, const iterator& y);friendconstexprbool operator==(const iterator& x, default_sentinel_t); friendconstexprbool operator<(const iterator& x, const iterator& y) requires random_access_range<Base>;friendconstexprbool operator>(const iterator& x, const iterator& y) requires random_access_range<Base>;friendconstexprbool operator<=(const iterator& x, const iterator& y) requires random_access_range<Base>;friendconstexprbool operator>=(const iterator& x, const iterator& y) requires random_access_range<Base>;friendconstexprauto operator<=>(const iterator& x, const iterator& y) requires random_access_range<Base>&& three_way_comparable<iterator_t<Base>>; friendconstexpr iterator operator+(const iterator& i, difference_type n) requires random_access_range<Base>;friendconstexpr iterator operator+(difference_type n, const iterator& i) requires random_access_range<Base>;friendconstexpr iterator operator-(const iterator& i, difference_type n) requires random_access_range<Base>;friendconstexpr difference_type operator-(const iterator& x, const iterator& y) requires sized_sentinel_for<iterator_t<Base>, iterator_t<Base>>; friendconstexpr difference_type operator-(default_sentinel_t y, const iterator& x) requires sized_sentinel_for<sentinel_t<Base>, iterator_t<Base>>;friendconstexpr difference_type operator-(const iterator& x, default_sentinel_t y) requires sized_sentinel_for<sentinel_t<Base>, iterator_t<Base>>;};}
[править]Шаблон класса std::ranges::slide_view
namespace std::ranges{template<class V> concept __slide_caches_nothing = random_access_range<V>&& sized_range<V>;// exposition only template<class V> concept __slide_caches_last =// exposition only!__slide_caches_nothing<V>&& bidirectional_range<V>&& common_range<V>; template<class V> concept __slide_caches_first =// exposition only!__slide_caches_nothing<V>&&!__slide_caches_last<V>; template<forward_range V> requires view<V>class slide_view :public view_interface<slide_view<V>>{ V base_;// exposition only range_difference_t<V> n_;// exposition only // class template slide_view::iteratortemplate<bool>class iterator;// exposition only // class slide_view::sentinelclass sentinel;// exposition only public:constexprexplicit slide_view(V base, range_difference_t<V> n); constexprauto begin() requires (!(__simple_view<V>&& __slide_caches_nothing<const V>));constexprauto begin()const requires __slide_caches_nothing<const V>; constexprauto end() requires (!(__simple_view<V>&& __slide_caches_nothing<const V>));constexprauto end()const requires __slide_caches_nothing<const V>; constexprauto size() requires sized_range<V>;constexprauto size()const requires sized_range<const V>;}; template<class R> slide_view(R&&, range_difference_t<R>)-> slide_view<views::all_t<R>>;}
[править]Шаблон класса std::ranges::slide_view::iterator
namespace std::ranges{template<forward_range V> requires view<V>template<bool Const>class slide_view<V>::iterator{using Base = __maybe_const<Const, V>;// exposition only iterator_t<Base> current_ = iterator_t<Base>();// exposition only iterator_t<Base> last_ele_ = iterator_t<Base>();// exposition only,// present only if Base models slide-caches-first range_difference_t<Base> n_ =0;// exposition only constexpr iterator(iterator_t<Base> current, // exposition only range_difference_t<Base> n) requires (!__slide_caches_first<Base>); constexpr iterator(iterator_t<Base> current, // exposition only iterator_t<Base> last_ele, range_difference_t<Base> n) requires __slide_caches_first<Base>; public:using iterator_category = input_iterator_tag;using iterator_concept =/* see description */;using value_type = decltype(views::counted(current_, n_));using difference_type = range_difference_t<Base>; iterator()=default;constexpr iterator(iterator<!Const> i) requires Const && convertible_to<iterator_t<V>, iterator_t<Base>>; constexprauto operator*()const;constexpr iterator& operator++();constexpr iterator operator++(int); constexpr iterator& operator--() requires bidirectional_range<Base>;constexpr iterator operator--(int) requires bidirectional_range<Base>; constexpr iterator& operator+=(difference_type x) requires random_access_range<Base>;constexpr iterator& operator-=(difference_type x) requires random_access_range<Base>; constexprauto operator[](difference_type n)const requires random_access_range<Base>; friendconstexprbool operator==(const iterator& x, const iterator& y); friendconstexprbool operator<(const iterator& x, const iterator& y) requires random_access_range<Base>;friendconstexprbool operator>(const iterator& x, const iterator& y) requires random_access_range<Base>;friendconstexprbool operator<=(const iterator& x, const iterator& y) requires random_access_range<Base>;friendconstexprbool operator>=(const iterator& x, const iterator& y) requires random_access_range<Base>;friendconstexprauto operator<=>(const iterator& x, const iterator& y) requires random_access_range<Base>&& three_way_comparable<iterator_t<Base>>; friendconstexpr iterator operator+(const iterator& i, difference_type n) requires random_access_range<Base>;friendconstexpr iterator operator+(difference_type n, const iterator& i) requires random_access_range<Base>;friendconstexpr iterator operator-(const iterator& i, difference_type n) requires random_access_range<Base>;friendconstexpr difference_type operator-(const iterator& x, const iterator& y) requires sized_sentinel_for<iterator_t<Base>, iterator_t<Base>>;};}
[править]Шаблон класса std::ranges::slide_view::sentinel
namespace std::ranges{template<forward_range V> requires view<V>class slide_view<V>::sentinel{ sentinel_t<V> end_ = sentinel_t<V>();// exposition onlyconstexprexplicit sentinel(sentinel_t<V> end);// exposition only public: sentinel()=default; friendconstexprbool operator==(const iterator<false>& x, const sentinel& y); friendconstexpr range_difference_t<V> operator-(const iterator<false>& x, const sentinel& y) requires sized_sentinel_for<sentinel_t<V>, iterator_t<V>>; friendconstexpr range_difference_t<V> operator-(const sentinel& y, const iterator<false>& x) requires sized_sentinel_for<sentinel_t<V>, iterator_t<V>>;};}
[править]Шаблон класса std::ranges::chunk_by_view
namespace std::ranges{template<forward_range V, indirect_binary_predicate<iterator_t<V>, iterator_t<V>> Pred> requires view<V>&& is_object_v<Pred>class chunk_by_view :public view_interface<chunk_by_view<V, Pred>>{ V base_ = V();// exposition only __movable_box<Pred> pred_ = Pred();// exposition only // class chunk_by_view::iteratorclass iterator;// exposition only public: chunk_by_view() requires default_initializable<V>&& default_initializable<Pred>=default;constexprexplicit chunk_by_view(V base, Pred pred); constexpr V base()const& requires copy_constructible<V>{return base_;}constexpr V base()&&{return std::move(base_);} constexprconst Pred& pred()const; constexpr iterator begin();constexprauto end(); constexpr iterator_t<V> __find_next(iterator_t<V>);// exposition onlyconstexpr iterator_t<V> __find_prev(iterator_t<V>)// exposition only requires bidirectional_range<V>;}; template<class R, class Pred> chunk_by_view(R&&, Pred)-> chunk_by_view<views::all_t<R>, Pred>;}
[править]Шаблон класса std::ranges::chunk_by_view::iterator
namespace std::ranges{template<forward_range V, indirect_binary_predicate<iterator_t<V>, iterator_t<V>> Pred> requires view<V>&& is_object_v<Pred>class chunk_by_view<V, Pred>::iterator{ chunk_by_view* parent_ = nullptr;// exposition only iterator_t<V> current_ = iterator_t<V>();// exposition only iterator_t<V> next_ = iterator_t<V>();// exposition only constexpr iterator(chunk_by_view& parent, iterator_t<V> current, // exposition only iterator_t<V> next); public:using value_type = subrange<iterator_t<V>>;using difference_type = range_difference_t<V>;using iterator_category = input_iterator_tag;using iterator_concept =/* see description */; iterator()=default; constexpr value_type operator*()const;constexpr iterator& operator++();constexpr iterator operator++(int); constexpr iterator& operator--() requires bidirectional_range<V>;constexpr iterator operator--(int) requires bidirectional_range<V>; friendconstexprbool operator==(const iterator& x, const iterator& y);friendconstexprbool operator==(const iterator& x, default_sentinel_t);};}
[править]Шаблон класса std::ranges::stride_view
namespace std::ranges{template<input_range V> requires view<V>class stride_view :public view_interface<stride_view<V>>{ V base_;// exposition only range_difference_t<V> stride_;// exposition only// class template stride_view::iteratortemplate<bool>class iterator;// exposition onlypublic:constexprexplicit stride_view(V base, range_difference_t<V> stride); constexpr V base()const& requires copy_constructible<V>{return base_;}constexpr V base()&&{return std::move(base_);} constexpr range_difference_t<V> stride()constnoexcept; constexprauto begin() requires (!__simple_view<V>){return iterator<false>(this, ranges::begin(base_));} constexprauto begin()const requires range<const V>{return iterator<true>(this, ranges::begin(base_));} constexprauto end() requires (!__simple_view<V>){ifconstexpr(common_range<V>&& sized_range<V>&& forward_range<V>){auto missing =(stride_ -ranges::distance(base_)% stride_)% stride_;return iterator<false>(this, ranges::end(base_), missing);}elseifconstexpr(common_range<V>&&!bidirectional_range<V>){return iterator<false>(this, ranges::end(base_));}else{return default_sentinel;}} constexprauto end()const requires range<const V>{ifconstexpr(common_range<const V>&& sized_range<const V>&& forward_range<const V>){auto missing =(stride_ -ranges::distance(base_)% stride_)% stride_;return iterator<true>(this, ranges::end(base_), missing);}elseifconstexpr(common_range<const V>&&!bidirectional_range<const V>){return iterator<true>(this, ranges::end(base_));}else{return default_sentinel;}} constexprauto size() requires sized_range<V>;constexprauto size()const requires sized_range<const V>;}; template<class R> stride_view(R&&, range_difference_t<R>)-> stride_view<views::all_t<R>>;}
[править]Шаблон класса std::ranges::stride_view::iterator
namespace std::ranges{template<input_range V> requires view<V>template<bool Const>class stride_view<V>::iterator{using Parent = __maybe_const<Const, stride_view>;// exposition onlyusing Base = __maybe_const<Const, V>;// exposition only iterator_t<Base> current_ = iterator_t<Base>();// exposition only sentinel_t<Base> end_ = sentinel_t<Base>();// exposition only range_difference_t<Base> stride_ =0;// exposition only range_difference_t<Base> missing_ =0;// exposition only constexpr iterator(Parent* parent, iterator_t<Base> current, // exposition only range_difference_t<Base> missing =0);public:using difference_type = range_difference_t<Base>;using value_type = range_value_t<Base>;using iterator_concept =/* see description */;using iterator_category =/* see description */;// not always present iterator() requires default_initializable<iterator_t<Base>>=default; constexpr iterator(iterator<!Const> other) requires Const && convertible_to<iterator_t<V>, iterator_t<Base>>&& convertible_to<sentinel_t<V>, sentinel_t<Base>>; constexpr iterator_t<Base> base()&&;constexprconst iterator_t<Base>& base()const&noexcept; constexpr decltype(auto) operator*()const{return*current_;} constexpr iterator& operator++();constexprvoid operator++(int);constexpr iterator operator++(int) requires forward_range<Base>; constexpr iterator& operator--() requires bidirectional_range<Base>;constexpr iterator operator--(int) requires bidirectional_range<Base>; constexpr iterator& operator+=(difference_type n) requires random_access_range<Base>;constexpr iterator& operator-=(difference_type n) requires random_access_range<Base>; constexpr decltype(auto) operator[](difference_type n)const requires random_access_range<Base>{return*(*this + n);} friendconstexprbool operator==(const iterator& x, default_sentinel_t); friendconstexprbool operator==(const iterator& x, const iterator& y) requires equality_comparable<iterator_t<Base>>; friendconstexprbool operator<(const iterator& x, const iterator& y) requires random_access_range<Base>; friendconstexprbool operator>(const iterator& x, const iterator& y) requires random_access_range<Base>; friendconstexprbool operator<=(const iterator& x, const iterator& y) requires random_access_range<Base>; friendconstexprbool operator>=(const iterator& x, const iterator& y) requires random_access_range<Base>; friendconstexprauto operator<=>(const iterator& x, const iterator& y) requires random_access_range<Base>&& three_way_comparable<iterator_t<Base>>; friendconstexpr iterator operator+(const iterator& x, difference_type n) requires random_access_range<Base>;friendconstexpr iterator operator+(difference_type n, const iterator& x) requires random_access_range<Base>;friendconstexpr iterator operator-(const iterator& x, difference_type n) requires random_access_range<Base>;friendconstexpr difference_type operator-(const iterator& x, const iterator& y) requires sized_sentinel_for<iterator_t<Base>, iterator_t<Base>>; friendconstexpr difference_type operator-(default_sentinel_t y, const iterator& x) requires sized_sentinel_for<sentinel_t<Base>, iterator_t<Base>>;friendconstexpr difference_type operator-(const iterator& x, default_sentinel_t y) requires sized_sentinel_for<sentinel_t<Base>, iterator_t<Base>>; friendconstexpr range_rvalue_reference_t<Base> iter_move(const iterator& i)noexcept(noexcept(ranges::iter_move(i.current_))); friendconstexprvoid iter_swap(const iterator& x, const iterator& y)noexcept(noexcept(ranges::iter_swap(x.current_, y.current_))) requires indirectly_swappable<iterator_t<Base>>;};}
[править]Шаблон класса std::ranges::cartesian_product_view
namespace std::ranges{template<bool Const, class First, class... Vs> concept __cartesian_product_is_random_access =// exposition only(random_access_range<__maybe_const<Const, First>>&& ... &&(random_access_range<__maybe_const<Const, Vs>>&& sized_range<__maybe_const<Const, Vs>>)); template<class R> concept __cartesian_product_common_arg =// exposition only common_range<R>||(sized_range<R>&& random_access_range<R>); template<bool Const, class First, class... Vs> concept __cartesian_product_is_bidirectional =// exposition only(bidirectional_range<__maybe_const<Const, First>>&& ... &&(bidirectional_range<__maybe_const<Const, Vs>>&& __cartesian_product_common_arg<__maybe_const<Const, Vs>>)); template<class First, class... Vs> concept __cartesian_product_is_common =// exposition only __cartesian_product_common_arg<First>; template<class... Vs> concept __cartesian_product_is_sized =// exposition only(sized_range<Vs>&& ...); template<bool Const, template<class>class FirstSent, class First, class... Vs> concept __cartesian_is_sized_sentinel =// exposition only(sized_sentinel_for<FirstSent<__maybe_const<Const, First>>, iterator_t<__maybe_const<Const, First>>>&& ... &&(sized_range<__maybe_const<Const, Vs>>&& sized_sentinel_for<iterator_t<__maybe_const<Const, Vs>>, iterator_t<__maybe_const<Const, Vs>>>)); template<__cartesian_product_common_arg R>constexprauto __cartesian_common_arg_end(R& r){// exposition onlyifconstexpr(common_range<R>){returnranges::end(r);}else{returnranges::begin(r)+ranges::distance(r);}} template<input_range First, forward_range... Vs> requires (view<First>&& ... && view<Vs>)class cartesian_product_view :public view_interface<cartesian_product_view<First, Vs...>>{private: tuple<First, Vs...> bases_;// exposition only// class template cartesian_product_view::iteratortemplate<bool Const>class iterator;// exposition onlypublic:constexpr cartesian_product_view()=default;constexprexplicit cartesian_product_view(First first_base, Vs... bases); constexpr iterator<false> begin() requires (!__simple_view<First>|| ... ||!__simple_view<Vs>);constexpr iterator<true> begin()const requires (range<const First>&& ... && range<const Vs>); constexpr iterator<false> end() requires ((!__simple_view<First>|| ... ||!__simple_view<Vs>)&& __cartesian_product_is_common<First, Vs...>);constexpr iterator<true> end()const requires __cartesian_product_is_common<const First, const Vs...>;constexpr default_sentinel_t end()constnoexcept; constexpr/* see description */ size() requires __cartesian_product_is_sized<First, Vs...>;constexpr/* see description */ size()const requires __cartesian_product_is_sized<const First, const Vs...>;}; template<class... Vs> cartesian_product_view(Vs&&...)-> cartesian_product_view<all_t<Vs>...>;}
[править]Шаблон класса std::ranges::cartesian_product_view::iterator
namespace std::ranges{template<input_range First, forward_range... Vs> requires (view<First>&& ... && view<Vs>)template<bool Const>class cartesian_product_view<First, Vs...>::iterator{public:using iterator_category = input_iterator_tag;using iterator_concept =/* see description */;using value_type = tuple<range_value_t<__maybe_const<Const, First>>, range_value_t<__maybe_const<Const, Vs>>...>;using reference = tuple<range_reference_t<__maybe_const<Const, First>>, range_reference_t<__maybe_const<Const, Vs>>...>;using difference_type =/* see description */; iterator() requires forward_range<__maybe_const<Const, First>>=default; constexpr iterator(iterator<!Const> i) requires Const &&(convertible_to<iterator_t<First>, iterator_t<const First>>&& ... && convertible_to<iterator_t<Vs>, iterator_t<const Vs>>); constexprauto operator*()const;constexpr iterator& operator++();constexprvoid operator++(int);constexpr iterator operator++(int) requires forward_range<__maybe_const<Const, First>>; constexpr iterator& operator--() requires __cartesian_product_is_bidirectional<Const, First, Vs...>;constexpr iterator operator--(int) requires __cartesian_product_is_bidirectional<Const, First, Vs...>; constexpr iterator& operator+=(difference_type x) requires __cartesian_product_is_random_access<Const, First, Vs...>;constexpr iterator& operator-=(difference_type x) requires __cartesian_product_is_random_access<Const, First, Vs...>; constexpr reference operator[](difference_type n)const requires __cartesian_product_is_random_access<Const, First, Vs...>; friendconstexprbool operator==(const iterator& x, const iterator& y) requires equality_comparable<iterator_t<__maybe_const<Const, First>>>; friendconstexprbool operator==(const iterator& x, default_sentinel_t); friendconstexprauto operator<=>(const iterator& x, const iterator& y) requires __all_random_access<Const, First, Vs...>; friendconstexpr iterator operator+(const iterator& x, difference_type y) requires __cartesian_product_is_random_access<Const, First, Vs...>;friendconstexpr iterator operator+(difference_type x, const iterator& y) requires __cartesian_product_is_random_access<Const, First, Vs...>;friendconstexpr iterator operator-(const iterator& x, difference_type y) requires __cartesian_product_is_random_access<Const, First, Vs...>;friendconstexpr difference_type operator-(const iterator& x, const iterator& y) requires __cartesian_is_sized_sentinel<Const, iterator_t, First, Vs...>; friendconstexpr difference_type operator-(iterator i, default_sentinel_t) requires __cartesian_is_sized_sentinel<Const, sentinel_t, First, Vs...>;friendconstexpr difference_type operator-(default_sentinel_t, iterator i) requires __cartesian_is_sized_sentinel<Const, sentinel_t, First, Vs...>; friendconstexprauto iter_move(const iterator& i)noexcept(/* see description */); friendconstexprvoid iter_swap(const iterator& l, const iterator& r)noexcept(/* see description */) requires (indirectly_swappable<iterator_t<__maybe_const<Const, First>>>&& ... && indirectly_swappable<iterator_t<__maybe_const<Const, Vs>>>); private: __maybe_const<Const, cartesian_product_view>* parent_ = nullptr;// exposition only tuple<iterator_t<__maybe_const<Const, First>>, iterator_t<__maybe_const<Const, Vs>>...> current_;// exposition only template<size_t N = sizeof...(Vs)>constexprvoid next();// exposition only template<size_t N = sizeof...(Vs)>constexprvoid prev();// exposition only template<class Tuple>constexpr difference_type __distance_from(Tuple t);// exposition only constexprexplicit iterator(tuple<iterator_t<__maybe_const<Const, First>>, iterator_t<__maybe_const<Const, Vs>>...> current);// exposition only};}
[править]Отчеты об ошибках
Следующие изменения поведения были применены с обратной силой к ранее опубликованным стандартам C++:
| Номер | Применён | Поведение в стандарте | Корректное поведение |
|---|---|---|---|
| LWG 3914 | C++23 | ограничение std::ranges::enumerate_view в аннотации неверно указано | исправлено |
