標準ライブラリヘッダ <ranges>

 

C++

言語

標準ライブラリヘッダ

フリースタンディング処理系とホスト処理系

名前付き要件

言語サポートライブラリ

コンセプトライブラリ(C++20)

診断ライブラリ

ユーティリティライブラリ

文字列ライブラリ

コンテナライブラリ

イテレータライブラリ

範囲ライブラリ(C++20)

アルゴリズムライブラリ

数値演算ライブラリ

ローカライゼーションライブラリ

入出力ライブラリ

ファイルシステムライブラリ(C++17)

正規表現ライブラリ(C++11)

アトミック操作ライブラリ(C++11)

スレッドサポートライブラリ(C++11)

技術仕様書

 

標準ライブラリヘッダ

言語サポート
<cstddef> <cstdlib> <version> <limits> <climits>	<cfloat> <cstdint> <new> <typeinfo>	<source_location> <exception> <initializer_list> <compare>	<coroutine> <csignal> <csetjmp> <cstdarg>
コンセプト
<concepts>
診断
<stdexcept>	<cassert>	<cerrno>	<system_error>
汎用ユーティリティ
<utility> <memory> <memory_resource> <scoped_allocator>	<bitset> <tuple> <optional> <any>	<variant> <type_traits> <ratio> <chrono>	<typeindex> <functional> <ctime>
文字列
<string> <string_view> <cstring>	<charconv> <format>	<cctype> <cwctype>	<cwchar> <cuchar>
ローカライゼーション
<locale>	<codecvt>	<clocale>
コンテナ
<span> <array> <vector>	<deque> <forward_list> <list>	<map> <set> <queue>	<unordered_map> <unordered_set> <stack>
イテレータ
<iterator>
範囲
<ranges>
アルゴリズム
<algorithm>	<execution>
数値演算
<complex> <random>	<valarray> <numeric>	<bit> <numbers>	<cfenv> <cmath>
入出力
<iosfwd> <ios> <iomanip> <streambuf>	<istream> <ostream> <iostream>	<sstream> <spanstream> <fstream> <syncstream>	<cstdio> <cinttypes> <strstream>
正規表現
<regex>
ファイルシステムサポート
<filesystem>
スレッドサポート
<thread> <atomic> <mutex>	<shared_mutex> <condition_variable> <future>	<stop_token> <semaphore>	<latch> <barrier>
C互換
<ciso646> <cstdalign>	<cstdbool> <ccomplex>	<ctgmath> <stdatomic.h>

 

このヘッダは範囲ライブラリの一部です。

名前空間エイリアス

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

std::ranges::view の短縮形として名前空間エイリアス std::view が提供されます。

コンセプト
範囲コンセプト
名前空間 std::ranges で定義
range	型が範囲である、つまり、 begin イテレータと end 番兵を提供することを指定します (コンセプト)
sized_range	範囲のサイズを定数時間で取得できることを指定します (コンセプト)
view	範囲がビューである、つまり、コピー/ムーブ/代入が定数時間であることを指定します (コンセプト)
input_range	input_iterator を満たすイテレータ型を持つ範囲を指定します (コンセプト)
output_range	output_iterator を満たすイテレータ型を持つ範囲を指定します (コンセプト)
forward_range	forward_iterator を満たすイテレータ型を持つ範囲を指定します (コンセプト)
bidirectional_range	bidirectional_iterator を満たすイテレータ型を持つ範囲を指定します (コンセプト)
random_access_range	random_access_iterator を満たすイテレータ型を持つ範囲を指定します (コンセプト)
contiguous_range	contiguous_iterator を満たすイテレータ型を持つ範囲を指定します (コンセプト)
common_range	範囲のイテレータ型と番兵型が同一であることを指定します (コンセプト)
ViewableRange	view に安全に変換可能であるための range に対する要件を指定します (コンセプト)
クラス
範囲プリミティブ
名前空間 std::ranges で定義
iterator_tsentinel_trange_difference_trange_size_t range_value_trange_reference_trange_rvalue_reference_t	範囲の関連型を取得します (エイリアステンプレート)
ビュー
名前空間 std::ranges で定義
view_interface	奇妙に再帰したテンプレートパターンを用いた view を定義するためのヘルパークラステンプレート (クラステンプレート)
subrange	イテレータと番兵の組を結合して view にします (クラステンプレート)
ダングリングイテレータ対策
名前空間 std::ranges で定義
dangling	ダングリングになるであろうためにイテレータまたは subrange が返されるべきではないことを表すプレースホルダ型 (クラス)
borrowed_iterator_tborrowed_subrange_t	borrowed_range のイテレータ型または subrange 型を取得します (エイリアステンプレート)
ファクトリ
名前空間 std::ranges で定義
empty_viewviews::empty	要素を持たない空の view (クラステンプレート)(変数テンプレート)
single_viewviews::single	指定された値の要素1個を格納する view (クラステンプレート)(カスタマイゼーションポイントオブジェクト)
iota_viewviews::iota	初期値を繰り返しインクリメントすることによって生成されるシーケンスから構成される view (クラステンプレート)(カスタマイゼーションポイントオブジェクト)
views::counted	イテレータとカウントから部分範囲を作成します (カスタマイゼーションポイントオブジェクト)
アダプタ
名前空間 std::ranges で定義
views::all_tviews::all	range のすべての要素を含む view (エイリアステンプレート)(範囲アダプタオブジェクト)
ref_view	何らかの他の range の要素の view (クラステンプレート)
filter_viewviews::filter	述語を満たす range の要素から構成される view (クラステンプレート)(範囲アダプタオブジェクト)
transform_viewviews::transform	各要素に変換関数を適用するシーケンスの view (クラステンプレート)(範囲アダプタオブジェクト)
take_viewviews::take	別の view の最初の N 個の要素から構成される view (クラステンプレート)(範囲アダプタオブジェクト)
join_viewviews::join	range の view を平坦化することによって得られるシーケンスから構成される view (クラステンプレート)(範囲アダプタオブジェクト)
split_viewviews::split	別の view を区切り文字で分割することによって得られる部分範囲群に対する view (クラステンプレート)(範囲アダプタオブジェクト)
common_viewviews::common	view を common_range に変換します (クラステンプレート)(範囲アダプタオブジェクト)
reverse_viewviews::reverse	別の双方向ビューの要素を逆順でイテレートする view (クラステンプレート)(範囲アダプタオブジェクト)
カスタマイゼーションポイントオブジェクト
範囲アクセス
名前空間 std::ranges で定義
ranges::begin (C++20)	範囲の先頭を指すイテレータを返します (カスタマイゼーションポイントオブジェクト)
ranges::end (C++20)	範囲の終端を示す番兵を返します (カスタマイゼーションポイントオブジェクト)
ranges::rbegin (C++20)	範囲の逆イテレータを返します (カスタマイゼーションポイントオブジェクト)
ranges::rend (C++20)	範囲の逆終端イテレータを返します (カスタマイゼーションポイントオブジェクト)
ranges::size (C++20)	サイズが定数時間で計算可能な範囲のサイズを取得します (カスタマイゼーションポイントオブジェクト)
ranges::empty (C++20)	範囲が空かどうか調べます (カスタマイゼーションポイントオブジェクト)
ranges::data (C++20)	隣接範囲の先頭を指すポインタを取得します (カスタマイゼーションポイントオブジェクト)

概要

#include <initializer_list>#include <iterator>   namespace std::ranges{inlinenamespace/* unspecified */{// range accessinlineconstexpr/* unspecified */ begin =/* unspecified */;inlineconstexpr/* unspecified */ end =/* unspecified */;inlineconstexpr/* unspecified */ cbegin =/* unspecified */;inlineconstexpr/* unspecified */ cend =/* unspecified */;inlineconstexpr/* unspecified */ rbegin =/* unspecified */;inlineconstexpr/* unspecified */ rend =/* unspecified */;inlineconstexpr/* unspecified */ crbegin =/* unspecified */;inlineconstexpr/* unspecified */ crend =/* unspecified */;   inlineconstexpr/* unspecified */ size =/* unspecified */;inlineconstexpr/* unspecified */ empty =/* unspecified */;inlineconstexpr/* unspecified */ data =/* unspecified */;inlineconstexpr/* unspecified */ cdata =/* unspecified */;}   // rangestemplate<class T>using iterator_t = decltype(ranges::begin(declval<T&>()));   template<class T>using sentinel_t = decltype(ranges::end(declval<T&>()));   template<class T> concept Range =/* see definition */;   // sized rangestemplate<class>inlineconstexprbool disable_sized_range =false;   template<class T> concept SizedRange =/* see definition */;   // viewstemplate<class T>inlineconstexprbool enable_view =/* see definition */;   struct view_base {};   template<class T> concept View =/* see definition */;   // other range refinementstemplate<class R, class T> concept OutputRange =/* see definition */;   template<class T> concept InputRange =/* see definition */;   template<class T> concept ForwardRange =/* see definition */;   template<class T> concept BidirectionalRange =/* see definition */;   template<class T> concept RandomAccessRange =/* see definition */;   template<class T> concept ContiguousRange =/* see definition */;   template<class T> concept CommonRange =/* see definition */;   template<class T> concept ViewableRange =/* see definition */;   // class template view_interfacetemplate<class D> requires is_class_v<D>&& Same<D, remove_cv_t<D>>class view_interface;   // sub-rangesenumclass subrange_kind :bool{ unsized, sized };   template<Iterator I, Sentinel<I> S = I, subrange_kind K =/* see definition */> requires (K == subrange_kind::sized||!SizedSentinel<S, I>)class subrange;   // dangling iterator handlingstruct dangling;   template<Range R>using borrowed_iterator_t = conditional_t<__ForwardingRange<R>, iterator_t<R>, dangling>;   template<Range R>using borrowed_subrange_t = conditional_t<__ForwardingRange<R>, subrange<iterator_t<R>>, dangling>;   // empty viewtemplate<class T> requires is_object_v<T>class empty_view;   namespace view {template<class T>inlineconstexpr empty_view<T> empty{};}   // single viewtemplate<CopyConstructible T> requires is_object_v<T>class single_view;   namespace view {inlineconstexpr/* unspecified */ single =/* unspecified */;}   // iota viewtemplate<WeaklyIncrementable W, Semiregular Bound = unreachable_sentinel_t> requires __WeaklyEqualityComparableWith<W, Bound>class iota_view;   namespace view {inlineconstexpr/* unspecified */ iota =/* unspecified */;}   // all viewnamespace view {inlineconstexpr/* unspecified */ all =/* unspecified */;}   template<ViewableRange R>using all_view = decltype(view::all(declval<R>()));   template<Range R> requires is_object_v<R>class ref_view;   // filter viewtemplate<InputRange V, IndirectUnaryPredicate<iterator_t<V>> Pred> requires View<V>&& is_object_v<Pred>class filter_view;   namespace view {inlineconstexpr/* unspecified */ filter =/* unspecified */;}   // transform viewtemplate<InputRange V, CopyConstructible F> requires View<V>&& is_object_v<F>&& RegularInvocable<F&, iter_reference_t<iterator_t<V>>>class transform_view;   namespace view {inlineconstexpr/* unspecified */ transform =/* unspecified */;}   // take viewtemplate<View>class take_view;   namespace view {inlineconstexpr/* unspecified */ take =/* unspecified */;}   // join viewtemplate<InputRange V> requires View<V>&& InputRange<iter_reference_t<iterator_t<V>>>&&(is_reference_v<iter_reference_t<iterator_t<V>>>|| View<iter_value_t<iterator_t<V>>>)class join_view;   namespace view {inlineconstexpr/* unspecified */ join =/* unspecified */;}   // split viewtemplate<class R> concept __TinyRange =/* see definition */;// exposition only   template<InputRange V, ForwardRange Pattern> requires View<V>&& View<Pattern>&& IndirectlyComparable<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to>&&(ForwardRange<V>|| __TinyRange<Pattern>)class split_view;   namespace view {inlineconstexpr/* unspecified */ split =/* unspecified */;}   // counted viewnamespace view {inlineconstexpr/* unspecified */ counted =/* unspecified */;}   // common viewtemplate<View V> requires (!CommonRange<V>)class common_view;   namespace view {inlineconstexpr/* unspecified */ common =/* unspecified */;}   // reverse viewtemplate<View V> requires BidirectionalRange<V>class reverse_view;   namespace view {inlineconstexpr/* unspecified */ reverse =/* unspecified */;}}   namespace std {namespace view = ranges::view;   template<class I, class S, ranges::subrange_kind K>struct tuple_size<ranges::subrange<I, S, K>>: integral_constant<size_t, 2>{};template<class I, class S, ranges::subrange_kind K>struct tuple_element<0, ranges::subrange<I, S, K>>{using type = I;};template<class I, class S, ranges::subrange_kind K>struct tuple_element<1, ranges::subrange<I, S, K>>{using type = S;};}

コンセプト range

namespace std::ranges{template<class T> concept __RangeImpl =// exposition only requires(T&& t){ ranges::begin(std::forward<T>(t));// sometimes equality-preserving (see definition) ranges::end(std::forward<T>(t));};   template<class T> concept Range = __RangeImpl<T&>;   template<class T> concept __ForwardingRange =// exposition only Range<T>&& __RangeImpl<T>;}

コンセプト sized_range

namespace std::ranges{template<class T> concept SizedRange = Range<T>&&!disable_sized_range<remove_cvref_t<T>>&& requires(T& t){ ranges::size(t);};}

コンセプト view

namespace std::ranges{template<class T>inlineconstexprbool enable_view =/* see definition */;   template<class T> concept View = Range<T>&& Semiregular<T>&& enable_view<T>;}

コンセプト output_range

namespace std::ranges{template<class R, class T> concept OutputRange = Range<R>&& OutputIterator<iterator_t<R>, T>;}

コンセプト input_range

namespace std::ranges{template<class T> concept InputRange = Range<T>&& InputIterator<iterator_t<T>>;}

コンセプト forward_range

namespace std::ranges{template<class T> concept ForwardRange = InputRange<T>&& ForwardIterator<iterator_t<T>>;}

コンセプト bidirectional_range

namespace std::ranges{template<class T> concept BidirectionalRange = ForwardRange<T>&& BidirectionalIterator<iterator_t<T>>;}

コンセプト random_access_range

namespace std::ranges{template<class T> concept RandomAccessRange = BidirectionalRange<T>&& RandomAccessIterator<iterator_t<T>>;}

コンセプト contiguous_range

namespace std::ranges{template<class T> concept ContiguousRange = RandomAccessRange<T>&& ContiguousIterator<iterator_t<T>>&& requires(T& t){{ ranges::data(t)}-> Same<add_pointer_t<iter_reference_t<iterator_t<T>>>>;};}

コンセプト common_range

namespace std::ranges{template<class T> concept CommonRange = Range<T>&& Same<iterator_t<T>, sentinel_t<T>>;}

コンセプト viewable_range

namespace std::ranges{template<class T> concept ViewableRange = Range<T>&&(__ForwardingRange<T>|| View<decay_t<T>>);}

ヘルパーコンセプト

namespace std::ranges{// unspecified, for name lookup onlytemplate<class R> concept __SimpleView =// exposition only View<R>&& Range<const R>&& Same<iterator_t<R>, iterator_t<const R>>&& Same<sentinel_t<R>, sentinel_t<const R>>;   template<InputIterator I> concept __HasArrow =// exposition only is_pointer_v<I>|| requires(I i){ i.operator->();};   template<class T, class U> concept __NotSameAs =// exposition only!Same<remove_cvref_t<T>, remove_cvref_t<U>>;   template<class I> concept _Decrementable =// exposition only Incrementable<I>&& requires(I i){{--i }-> Same<I&>;{ i--}-> Same<I>;};   template<class I> concept _Advanceable =// exposition only _Decrementable<I>&& StrictTotallyOrdered<I>&& requires(I i, const I j, const iter_difference_t<I> n){{ i += n }-> Same<I&>;{ i -= n }-> Same<I&>;{ j + n }-> Same<I>;{ n + j }-> Same<I>;{ j - n }-> Same<I>;{ j - j }-> Same<iter_difference_t<I>>;};}

注: これらの名前は説明専用であり、インタフェースの一部ではありません。

クラステンプレート std::ranges::view_interface

namespace std::ranges{template<class D> requires is_class_v<D>&& Same<D, remove_cv_t<D>>class view_interface :public view_base {private:constexpr D& derived()noexcept{// exposition onlyreturnstatic_cast<D&>(*this);}constexprconst D& derived()constnoexcept{// exposition onlyreturnstatic_cast<const D&>(*this);}public:constexprbool empty() requires ForwardRange<D>{return ranges::begin(derived())== ranges::end(derived());}constexprbool empty()const requires ForwardRange<const D>{return ranges::begin(derived())== ranges::end(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 ContiguousIterator<iterator_t<D>>{return ranges::empty(derived())? nullptr : addressof(*ranges::begin(derived()));}constexprauto data()const requires Range<const D>&& ContiguousIterator<iterator_t<const D>>{return ranges::empty(derived())? nullptr : addressof(*ranges::begin(derived()));}   constexprauto size() requires ForwardRange<D>&& SizedSentinel<sentinel_t<D>, iterator_t<D>>{return ranges::end(derived())- ranges::begin(derived());}constexprauto size()const requires ForwardRange<const D>&& SizedSentinel<sentinel_t<const D>, iterator_t<const D>>{return ranges::end(derived())- ranges::begin(derived());}   constexpr decltype(auto) front() requires ForwardRange<D>;constexpr decltype(auto) front()const requires ForwardRange<const D>;   constexpr decltype(auto) back() requires BidirectionalRange<D>&& CommonRange<D>;constexpr decltype(auto) back()const requires BidirectionalRange<const D>&& CommonRange<const D>;   template<RandomAccessRange R = D>constexpr decltype(auto) operator[](iter_difference_t<iterator_t<R>> n){return ranges::begin(derived())[n];}template<RandomAccessRange R =const D>constexpr decltype(auto) operator[](iter_difference_t<iterator_t<R>> n)const{return ranges::begin(derived())[n];}};}

クラステンプレート std::ranges::subrange

namespace std::ranges{template<class T> concept __PairLike =// exposition only!is_reference_v<T>&& requires(T t){typename tuple_size<T>::type;// ensures tuple_­size<T> is complete requires DerivedFrom<tuple_size<T>, integral_constant<size_t, 2>>;typename tuple_element_t<0, remove_const_t<T>>;typename tuple_element_t<1, remove_const_t<T>>;{ get<0>(t)}->const tuple_element_t<0, T>&;{ get<1>(t)}->const tuple_element_t<1, T>&;};   template<class T, class U, class V> concept __PairLikeConvertibleTo =// exposition only!Range<T>&& __PairLike<remove_reference_t<T>>&& requires(T&& t){{ get<0>(std::forward<T>(t))}-> ConvertibleTo<U>;{ get<1>(std::forward<T>(t))}-> ConvertibleTo<V>;};   template<class T, class U, class V> concept __PairLikeConvertibleFrom =// exposition only!Range<T>&& __PairLike<T>&& Constructible<T, U, V>;   template<class T> concept __IteratorSentinelPair =// exposition only!Range<T>&& __PairLike<T>&& Sentinel<tuple_element_t<1, T>, tuple_element_t<0, T>>;   template<Iterator I, Sentinel<I> S = I, subrange_kind K = SizedSentinel<S, I>? subrange_kind::sized: subrange_kind::unsized> requires (K == subrange_kind::sized||!SizedSentinel<S, I>)class subrange :public view_interface<subrange<I, S, K>>{private:staticconstexprbool StoreSize =// exposition only K == subrange_kind::sized&&!SizedSentinel<S, I>; I begin_ = I();// exposition only S end_ = S();// exposition only iter_difference_t<I> size_ =0;// exposition only; present only// when StoreSize is truepublic: subrange()=default;   constexpr subrange(I i, S s) requires (!StoreSize);   constexpr subrange(I i, S s, iter_difference_t<I> n) requires (K == subrange_kind::sized);   template<__NotSameAs<subrange> R> requires __ForwardingRange<R>&& ConvertibleTo<iterator_t<R>, I>&& ConvertibleTo<sentinel_t<R>, S>constexpr subrange(R&& r) requires (!StoreSize || SizedRange<R>);   template<__ForwardingRange R> requires ConvertibleTo<iterator_t<R>, I>&& ConvertibleTo<sentinel_t<R>, S>constexpr subrange(R&& r, iter_difference_t<I> n) requires (K == subrange_kind::sized): subrange{ranges::begin(r), ranges::end(r), n}{}   template<__NotSameAs<subrange> PairLike> requires __PairLikeConvertibleTo<PairLike, I, S>constexpr subrange(PairLike&& r) requires (!StoreSize): subrange{std::get<0>(std::forward<PairLike>(r)), std::get<1>(std::forward<PairLike>(r))}{}   template<__PairLikeConvertibleTo<I, S> PairLike>constexpr subrange(PairLike&& r, iter_difference_t<I> n) requires (K == subrange_kind::sized): subrange{std::get<0>(std::forward<PairLike>(r)), std::get<1>(std::forward<PairLike>(r)), n}{}   template<__NotSameAs<subrange> PairLike> requires __PairLikeConvertibleFrom<PairLike, const I&, const S&>constexpr operator PairLike()const;   constexpr I begin()const;constexpr S end()const;   constexprbool empty()const;constexpr iter_difference_t<I> size()const requires (K == subrange_kind::sized);   [[nodiscard]]constexpr subrange next(iter_difference_t<I> n =1)const;[[nodiscard]]constexpr subrange prev(iter_difference_t<I> n =1)const requires BidirectionalIterator<I>;constexpr subrange& advance(iter_difference_t<I> n);   friendconstexpr I begin(subrange&& r){return r.begin();}friendconstexpr S end(subrange&& r){return r.end();}};   template<Iterator I, Sentinel<I> S> subrange(I, S, iter_difference_t<I>)-> subrange<I, S, subrange_kind::sized>;   template<__IteratorSentinelPair P> subrange(P)-> subrange<tuple_element_t<0, P>, tuple_element_t<1, P>>;   template<__IteratorSentinelPair P> subrange(P, iter_difference_t<tuple_element_t<0, P>>)-> subrange<tuple_element_t<0, P>, tuple_element_t<1, P>, subrange_kind::sized>;   template<__ForwardingRange R> subrange(R&&)-> subrange<iterator_t<R>, sentinel_t<R>, (SizedRange<R>|| SizedSentinel<sentinel_t<R>, iterator_t<R>>)? subrange_kind::sized: subrange_kind::unsized>;   template<__ForwardingRange R> subrange(R&&, iter_difference_t<iterator_t<R>>)-> subrange<iterator_t<R>, sentinel_t<R>, subrange_kind::sized>;   template<size_t N, class I, class S, subrange_kind K> requires (N <2)constexprauto get(const subrange<I, S, K>& r);}   namespace std {using ranges::get;}

クラス std::ranges::dangling

namespace std::ranges{struct dangling {constexpr dangling()noexcept=default;template<class... Args>constexpr dangling(Args&&...)noexcept{}};}

クラステンプレート 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 ptrdiff_t size()noexcept{return0;}staticconstexprbool empty()noexcept{returntrue;}   friendconstexpr T* begin(empty_view)noexcept{return nullptr;}friendconstexpr T* end(empty_view)noexcept{return nullptr;}};}

クラステンプレート std::ranges::empty_view

namespace std::ranges{template<CopyConstructible T> requires is_object_v<T>class single_view :public view_interface<single_view<T>>{private: semiregular_box<T> value_;// exposition onlypublic: single_view()=default;constexprexplicit single_view(const T& t);constexprexplicit single_view(T&& t);template<class... Args> requires Constructible<T, Args...>constexpr single_view(in_place_t, Args&&... args);   constexpr T* begin()noexcept;constexprconst T* begin()constnoexcept;constexpr T* end()noexcept;constexprconst T* end()constnoexcept;staticconstexpr ptrdiff_t size()noexcept;constexpr T* data()noexcept;constexprconst T* data()constnoexcept;};}

クラステンプレート std::ranges::iota_view

namespace std::ranges{template<class I> concept _Decrementable =// exposition only/* see definition */;template<class I> concept _Advanceable =// exposition only/* see definition */;   template<WeaklyIncrementable W, Semiregular Bound = unreachable_sentinel_t> requires __WeaklyEqualityComparableWith<W, Bound>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 onlypublic: iota_view()=default;constexprexplicit iota_view(W value);constexpr iota_view(type_identity_t<W> value, type_identity_t<Bound> bound);   constexpr iterator begin()const;constexpr sentinel end()const;constexpr iterator end()const requires Same<W, Bound>;   constexprauto size()const requires (Same<W, Bound>&& _Advanceable<W>)||(Integral<W>&& Integral<Bound>)|| SizedSentinel<Bound, W>{return bound_ - value_;}};   template<class W, class Bound> requires (!Integral<W>||!Integral<Bound>|| is_signed_v<W>== is_signed_v<Bound>) iota_view(W, Bound)-> iota_view<W, Bound>;}

クラス std::ranges::iota_view::iterator

namespace std::ranges{template<class W, class Bound>struct iota_view<W, Bound>::iterator{private: W value_ = W();// exposition onlypublic:using iterator_category =/* see definition */;using value_type = W;using difference_type = iter_difference_t<W>;   iterator()=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 EqualityComparable<W>;friendconstexprbool operator!=(const iterator& x, const iterator& y) requires EqualityComparable<W>;   friendconstexprbool operator<(const iterator& x, const iterator& y) requires StrictTotallyOrdered<W>;friendconstexprbool operator>(const iterator& x, const iterator& y) requires StrictTotallyOrdered<W>;friendconstexprbool operator<=(const iterator& x, const iterator& y) requires StrictTotallyOrdered<W>;friendconstexprbool operator>=(const iterator& x, const iterator& y) requires StrictTotallyOrdered<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<class W, class Bound>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);friendconstexprbool operator==(const sentinel& x, const iterator& y);friendconstexprbool operator!=(const iterator& x, const sentinel& y);friendconstexprbool operator!=(const sentinel& x, const iterator& y);};}

クラステンプレート 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_ = nullptr;// exposition onlypublic:constexpr ref_view()noexcept=default;   template<__NotSameAs<ref_view> T> requires /* see definition */constexpr ref_view(T&& t);   constexpr R& base()const{return*r_;}   constexpr iterator_t<R> begin()const{return ranges::begin(*r_);}constexpr sentinel_t<R> end()const{return ranges::end(*r_);}   constexprbool empty()const requires requires { ranges::empty(*r_);}{return ranges::empty(*r_);}   constexprauto size()const requires SizedRange<R>{return ranges::size(*r_);}   constexprauto data()const requires ContiguousRange<R>{return ranges::data(*r_);}   friendconstexpr iterator_t<R> begin(ref_view r){return r.begin();}   friendconstexpr sentinel_t<R> end(ref_view r){return r.end();}};template<class R> ref_view(R&)-> ref_view<R>;}

クラステンプレート std::ranges::filter_view

namespace std::ranges{template<InputRange V, IndirectUnaryPredicate<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 semiregular_box<Pred> pred_;// exposition only   // class filter_view​::​iteratorclass iterator;// exposition only// class filter_view​::​sentinelclass sentinel;// exposition only   public: filter_view()=default;constexpr filter_view(V base, Pred pred);template<InputRange R> requires ViewableRange<R>&& Constructible<V, all_view<R>>constexpr filter_view(R&& r, Pred pred);   constexpr V base()const;   constexpr iterator begin();constexprauto end(){ifconstexpr(CommonRange<V>)return iterator{*this, ranges::end(base_)};elsereturn sentinel{*this};}};   template<class R, class Pred> filter_view(R&&, Pred)-> filter_view<all_view<R>, Pred>;}

クラス std::ranges::filter_view::iterator

namespace std::ranges{template<class V, class Pred>class filter_view<V, Pred>::iterator{private: iterator_t<V> current_ = iterator_t<V>();// exposition only filter_view* parent_ = nullptr;// exposition onlypublic:using iterator_concept =/* see definition */;using iterator_category =/* see definition */;using value_type = iter_value_t<iterator_t<V>>;using difference_type = iter_difference_t<iterator_t<V>>;   iterator()=default;constexpr iterator(filter_view& parent, iterator_t<V> current);   constexpr iterator_t<V> base()const;constexpr iter_reference_t<iterator_t<V>> operator*()const;constexpr iterator_t<V> operator->()const requires has-arrow<iterator_t<V>>;   constexpr iterator& operator++();constexprvoid operator++(int);constexpr iterator operator++(int) requires ForwardRange<V>;   constexpr iterator& operator--() requires BidirectionalRange<V>;constexpr iterator operator--(int) requires BidirectionalRange<V>;   friendconstexprbool operator==(const iterator& x, const iterator& y) requires EqualityComparable<iterator_t<V>>;friendconstexprbool operator!=(const iterator& x, const iterator& y) requires EqualityComparable<iterator_t<V>>;   friendconstexpr iter_rvalue_reference_t<iterator_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 IndirectlySwappable<iterator_t<V>>;};}

クラス std::ranges::filter_view::sentinel

namespace std::ranges{template<class V, class Pred>class filter_view<V, Pred>::sentinel{private: sentinel_t<V> end_ = sentinel_t<V>();// exposition onlypublic: sentinel()=default;constexprexplicit sentinel(filter_view& parent);   constexpr sentinel_t<V> base()const;   friendconstexprbool operator==(const iterator& x, const sentinel& y);friendconstexprbool operator==(const sentinel& x, const iterator& y);friendconstexprbool operator!=(const iterator& x, const sentinel& y);friendconstexprbool operator!=(const sentinel& x, const iterator& y);};}

クラステンプレート std::ranges::transform_view

namespace std::ranges{template<InputRange V, CopyConstructible F> requires View<V>&& is_object_v<F>&& RegularInvocable<F&, iter_reference_t<iterator_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 semiregular_box<F> fun_;// exposition only   public: transform_view()=default;constexpr transform_view(V base, F fun);template<InputRange R> requires ViewableRange<R>&& Constructible<V, all_view<R>>constexpr transform_view(R&& r, F fun);   constexpr V base()const;   constexpr iterator<false> begin();constexpr iterator<true> begin()const requires Range<const V>&& RegularInvocable<const F&, iter_reference_t<iterator_t<const V>>>;   constexpr sentinel<false> end();constexpr iterator<false> end() requires CommonRange<V>;constexpr sentinel<true> end()const requires Range<const V>&& RegularInvocable<const F&, iter_reference_t<iterator_t<const V>>>;constexpr iterator<true> end()const requires CommonRange<const V>&& RegularInvocable<const F&, iter_reference_t<iterator_t<const V>>>;   constexprauto size() requires SizedRange<V>{return ranges::size(base_);}constexprauto size()const requires SizedRange<const V>{return ranges::size(base_);}};   template<class R, class F> transform_view(R&&, F)-> transform_view<all_view<R>, F>;}

クラステンプレート std::ranges::transform_view::iterator

namespace std::ranges{template<class V, class F>template<bool Const>class transform_view<V, F>::iterator{private:using Parent =// exposition only conditional_t<Const, const transform_view, transform_view>;using Base =// exposition only conditional_t<Const, const V, V>; iterator_t<Base> current_ =// exposition only iterator_t<Base>(); Parent* parent_ = nullptr;// exposition onlypublic:using iterator_concept =/* see definition */;using iterator_category =/* see definition */;using value_type = remove_cvref_t<invoke_result_t<F&, iter_reference_t<iterator_t<Base>>>>;using difference_type = iter_difference_t<iterator_t<Base>>;   iterator()=default;constexpr iterator(Parent& parent, iterator_t<Base> current);constexpr iterator(iterator<!Const> i) requires Const && ConvertibleTo<iterator_t<V>, iterator_t<Base>>;   constexpr iterator_t<Base> base()const;constexpr decltype(auto) operator*()const{return invoke(*parent_->fun_, *current_);}   constexpr iterator& operator++();constexprvoid operator++(int);constexpr iterator operator++(int) requires ForwardRange<Base>;   constexpr iterator& operator--() requires BidirectionalRange<Base>;constexpr iterator operator--(int) requires BidirectionalRange<Base>;   constexpr iterator& operator+=(difference_type n) requires RandomAccessRange<Base>;constexpr iterator& operator-=(difference_type n) requires RandomAccessRange<Base>;constexpr decltype(auto) operator[](difference_type n)const requires RandomAccessRange<Base>{return invoke(*parent_->fun_, current_[n]);}   friendconstexprbool operator==(const iterator& x, const iterator& y) requires EqualityComparable<iterator_t<Base>>;friendconstexprbool operator!=(const iterator& x, const iterator& y) requires EqualityComparable<iterator_t<Base>>;   friendconstexprbool operator<(const iterator& x, const iterator& y) requires RandomAccessRange<Base>;friendconstexprbool operator>(const iterator& x, const iterator& y) requires RandomAccessRange<Base>;friendconstexprbool operator<=(const iterator& x, const iterator& y) requires RandomAccessRange<Base>;friendconstexprbool operator>=(const iterator& x, const iterator& y) requires RandomAccessRange<Base>;   friendconstexpr iterator operator+(iterator i, difference_type n) requires RandomAccessRange<Base>;friendconstexpr iterator operator+(difference_type n, iterator i) requires RandomAccessRange<Base>;   friendconstexpr iterator operator-(iterator i, difference_type n) requires RandomAccessRange<Base>;friendconstexpr difference_type operator-(const iterator& x, const iterator& y) requires RandomAccessRange<Base>;   friendconstexpr decltype(auto) iter_move(const iterator& i)noexcept(noexcept(invoke(*i.parent_->fun_, *i.current_))){ifconstexpr(is_lvalue_reference_v<decltype(*i)>)return std::move(*i);elsereturn*i;}   friendconstexprvoid iter_swap(const iterator& x, const iterator& y)noexcept(noexcept(ranges::iter_swap(x.current_, y.current_))) requires IndirectlySwappable<iterator_t<Base>>;};}

クラステンプレート std::ranges::transform_view::sentinel

namespace std::ranges{template<class V, class F>template<bool Const>class transform_view<V, F>::sentinel{private:using Parent =// exposition only conditional_t<Const, const transform_view, transform_view>;using Base = conditional_t<Const, const V, 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 && ConvertibleTo<sentinel_t<V>, sentinel_t<Base>>;   constexpr sentinel_t<Base> base()const;   friendconstexprbool operator==(const iterator<Const>& x, const sentinel& y);friendconstexprbool operator==(const sentinel& x, const iterator<Const>& y);friendconstexprbool operator!=(const iterator<Const>& x, const sentinel& y);friendconstexprbool operator!=(const sentinel& x, const iterator<Const>& y);   friendconstexpr iter_difference_t<iterator_t<Base>> operator-(const iterator<Const>& x, const sentinel& y) requires SizedSentinel<sentinel_t<Base>, iterator_t<Base>>;friendconstexpr iter_difference_t<iterator_t<Base>> operator-(const sentinel& y, const iterator<Const>& x) requires SizedSentinel<sentinel_t<Base>, iterator_t<Base>>;};}

クラステンプレート 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 iter_difference_t<iterator_t<V>> count_ =0;// exposition only// class template take_­view​::​sentineltemplate<bool>struct sentinel;// exposition onlypublic: take_view()=default;constexpr take_view(V base, iter_difference_t<iterator_t<V>> count);template<ViewableRange R> requires Constructible<V, all_view<R>>constexpr take_view(R&& r, iter_difference_t<iterator_t<V>> count);   constexpr V base()const;   constexprauto begin() requires (!__SimpleView<V>){ifconstexpr(SizedRange<V>){ifconstexpr(RandomAccessRange<V>)return ranges::begin(base_);elsereturn counted_iterator{ranges::begin(base_), size()};}elsereturn counted_iterator{ranges::begin(base_), count_};}   constexprauto begin()const requires Range<const V>{ifconstexpr(SizedRange<const V>){ifconstexpr(RandomAccessRange<const V>)return ranges::begin(base_);elsereturn counted_iterator{ranges::begin(base_), size()};}elsereturn counted_iterator{ranges::begin(base_), count_};}   constexprauto end() requires (!__SimpleView<V>){ifconstexpr(SizedRange<V>){ifconstexpr(RandomAccessRange<V>)return ranges::begin(base_)+ size();elsereturn default_sentinel;}elsereturn sentinel<false>{ranges::end(base_)};}   constexprauto end()const requires Range<const V>{ifconstexpr(SizedRange<const V>){ifconstexpr(RandomAccessRange<const V>)return ranges::begin(base_)+ size();elsereturn default_sentinel;}elsereturn sentinel<true>{ranges::end(base_)};}   constexprauto size() requires SizedRange<V>{auto n = ranges::size(base_);return ranges::min(n, static_cast<decltype(n)>(count_));}   constexprauto size()const requires SizedRange<const V>{auto n = ranges::size(base_);return ranges::min(n, static_cast<decltype(n)>(count_));}};   template<Range R> take_view(R&&, iter_difference_t<iterator_t<R>>)-> take_view<all_view<R>>;}

クラステンプレート std::ranges::take_view::sentinel

namespace std::ranges{template<class V>template<bool Const>class take_view<V>::sentinel{private:using Base = conditional_t<Const, const V, V>;// exposition onlyusing CI = counted_iterator<iterator_t<Base>>;// 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 && ConvertibleTo<sentinel_t<V>, sentinel_t<Base>>;   constexpr sentinel_t<Base> base()const;   friendconstexprbool operator==(const sentinel& x, const CI& y);friendconstexprbool operator==(const CI& y, const sentinel& x);friendconstexprbool operator!=(const sentinel& x, const CI& y);friendconstexprbool operator!=(const CI& y, const sentinel& x);};}

クラステンプレート std::ranges::join_view

namespace std::ranges{template<InputRange V> requires View<V>&& InputRange<iter_reference_t<iterator_t<V>>>&&(is_reference_v<iter_reference_t<iterator_t<V>>>|| View<iter_value_t<iterator_t<V>>>)class join_view :public view_interface<join_view<V>>{private:using InnerRng =// exposition only iter_reference_t<iterator_t<V>>;// 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 all_view<InnerRng> inner_ =// exposition only, present only when all_view<InnerRng>();// !is_reference_v<InnerRng>public: join_view()=default;constexprexplicit join_view(V base);   template<InputRange R> requires ViewableRange<R>&& Constructible<V, all_view<R>>constexprexplicit join_view(R&& r);   constexprauto begin(){return iterator<__SimpleView<V>>{*this, ranges::begin(base_)};}   constexprauto begin()const requires InputRange<const V>&& is_reference_v<iter_reference_t<iterator_t<const V>>>{return iterator<true>{*this, ranges::begin(base_)};}   constexprauto end(){ifconstexpr(ForwardRange<V>&& is_reference_v<InnerRng>&& ForwardRange<InnerRng>&& CommonRange<V>&& CommonRange<InnerRng>)return iterator<__SimpleView<V>>{*this, ranges::end(base_)};elsereturn sentinel<__SimpleView<V>>{*this};}   constexprauto end()const requires InputRange<const V>&& is_reference_v<iter_reference_t<iterator_t<const V>>>{ifconstexpr(ForwardRange<const V>&& is_reference_v<iter_reference_t<iterator_t<const V>>>&& ForwardRange<iter_reference_t<iterator_t<const V>>>&& CommonRange<const V>&& CommonRange<iter_reference_t<iterator_t<const V>>>)return iterator<true>{*this, ranges::end(base_)};elsereturn sentinel<true>{*this};}};   template<class R>explicit join_view(R&&)-> join_view<all_view<R>>;}

クラステンプレート std::ranges::join_view::iterator

namespace std::ranges{template<class V>template<bool Const>struct join_view<V>::iterator{private:using Parent =// exposition only conditional_t<Const, const join_view, join_view>;using Base = conditional_t<Const, const V, V>;// exposition only   staticconstexprbool ref_is_glvalue =// exposition only is_reference_v<iter_reference_t<iterator_t<Base>>>;   iterator_t<Base> outer_ = iterator_t<Base>();// exposition only iterator_t<iter_reference_t<iterator_t<Base>>> inner_ =// exposition only iterator_t<iter_reference_t<iterator_t<Base>>>(); Parent* parent_ = nullptr;// exposition only   constexprvoid satisfy();// exposition onlypublic:using iterator_concept =/* see definition */;using iterator_category =/* see definition */;using value_type = iter_value_t<iterator_t<iter_reference_t<iterator_t<Base>>>>;using difference_type =/* see definition */;   iterator()=default;constexpr iterator(Parent& parent, iterator_t<V> outer);constexpr iterator(iterator<!Const> i) requires Const && ConvertibleTo<iterator_t<V>, iterator_t<Base>>&& ConvertibleTo<iterator_t<InnerRng>, iterator_t<iter_reference_t<iterator_t<Base>>>>;   constexpr decltype(auto) operator*()const{return*inner_;}   constexpr iterator_t<Base> operator->()const requires __HasArrow<iterator_t<Base>>;   constexpr iterator& operator++();constexprvoid operator++(int);constexpr iterator operator++(int) requires ref_is_glvalue && ForwardRange<Base>&& ForwardRange<iter_reference_t<iterator_t<Base>>>;   constexpr iterator& operator--() requires ref_is_glvalue && BidirectionalRange<Base>&& BidirectionalRange<iter_reference_t<iterator_t<Base>>>;   constexpr iterator operator--(int) requires ref_is_glvalue && BidirectionalRange<Base>&& BidirectionalRange<iter_reference_t<iterator_t<Base>>>;   friendconstexprbool operator==(const iterator& x, const iterator& y) requires ref_is_glvalue && EqualityComparable<iterator_t<Base>>&& EqualityComparable<iterator_t<iter_reference_t<iterator_t<Base>>>>;   friendconstexprbool operator!=(const iterator& x, const iterator& y) requires ref_is_glvalue && EqualityComparable<iterator_t<Base>>&& EqualityComparable<iterator_t<iter_reference_t<iterator_t<Base>>>>;   friendconstexpr decltype(auto) iter_move(const iterator& i)noexcept(noexcept(ranges::iter_move(i.inner_))){return ranges::iter_move(i.inner_);}   friendconstexprvoid iter_swap(const iterator& x, const iterator& y)noexcept(noexcept(ranges::iter_swap(x.inner_, y.inner_)));};}

クラステンプレート std::ranges::join_view::sentinel

namespace std::ranges{template<class V>template<bool Const>struct join_view<V>::sentinel{private:using Parent =// exposition only conditional_t<Const, const join_view, join_view>;using Base = conditional_t<Const, const V, V>;// exposition only sentinel_t<Base> end_ = sentinel_t<Base>();// exposition onlypublic: sentinel()=default;   constexprexplicit sentinel(Parent& parent);constexpr sentinel(sentinel<!Const> s) requires Const && ConvertibleTo<sentinel_t<V>, sentinel_t<Base>>;   friendconstexprbool operator==(const iterator<Const>& x, const sentinel& y);friendconstexprbool operator==(const sentinel& x, const iterator<Const>& y);friendconstexprbool operator!=(const iterator<Const>& x, const sentinel& y);friendconstexprbool operator!=(const sentinel& x, const iterator<Const>& y);};}

クラステンプレート std::ranges::split_­view

namespace std::ranges{template<auto>struct __require_constant;// exposition only   template<class R> concept __TinyRange =// exposition only SizedRange<R>&& requires {typename __require_constant<remove_reference_t<R>::size()>;}&&(remove_reference_t<R>::size()<=1);   template<InputRange V, ForwardRange Pattern> requires View<V>&& View<Pattern>&& IndirectlyComparable<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to>&&(ForwardRange<V>|| __TinyRange<Pattern>)class split_view :public view_interface<split_view<V, Pattern>>{private: V base_ = V();// exposition only Pattern pattern_ = Pattern();// exposition only iterator_t<V> current_ = iterator_t<V>();// exposition only, present only if // !ForwardRange<V>// class template split_­view​::​outer_­iteratortemplate<bool>struct outer_iterator;// exposition only// class template split_­view​::​inner_­iteratortemplate<bool>struct inner_iterator;// exposition onlypublic: split_view()=default;constexpr split_view(V base, Pattern pattern);   template<InputRange R, ForwardRange P> requires Constructible<V, all_view<R>>&& Constructible<Pattern, all_view<P>>constexpr split_view(R&& r, P&& p);   template<InputRange R> requires Constructible<V, all_view<R>>&& Constructible<Pattern, single_view<iter_value_t<iterator_t<R>>>>constexpr split_view(R&& r, iter_value_t<iterator_t<R>> e);   constexprauto begin(){ifconstexpr(ForwardRange<V>)return outer_iterator<__SimpleView<V>>{*this, ranges::begin(base_)};else{ current_ = ranges::begin(base_);return outer_iterator<false>{*this};}}   constexprauto begin()const requires ForwardRange<V>&& ForwardRange<const V>{return outer_iterator<true>{*this, ranges::begin(base_)};}   constexprauto end() requires ForwardRange<V>&& CommonRange<V>{return outer_iterator<__SimpleView<V>>{*this, ranges::end(base_)};}   constexprauto end()const{ifconstexpr(ForwardRange<V>&& ForwardRange<const V>&& CommonRange<const V>)return outer_iterator<true>{*this, ranges::end(base_)};elsereturn default_sentinel;}};   template<class R, class P> split_view(R&&, P&&)-> split_view<all_view<R>, all_view<P>>;   template<InputRange R> split_view(R&&, iter_value_t<iterator_t<R>>)-> split_view<all_view<R>, single_view<iter_value_t<iterator_t<R>>>>;}

クラステンプレート std::ranges::split_view::outer_iterator

namespace std::ranges{template<class V, class Pattern>template<bool Const>struct split_view<V, Pattern>::outer_iterator{private:using Parent =// exposition only conditional_t<Const, const split_view, split_view>;using Base =// exposition only conditional_t<Const, const V, V>; Parent* parent_ = nullptr;// exposition only iterator_t<Base> current_ =// exposition only, present only iterator_t<Base>();// if V models ForwardRange   public:using iterator_concept = conditional_t<ForwardRange<Base>, forward_iterator_tag, input_iterator_tag>;using iterator_category = input_iterator_tag;struct value_type;using difference_type = iter_difference_t<iterator_t<Base>>;   outer_iterator()=default;constexprexplicit outer_iterator(Parent& parent) requires (!ForwardRange<Base>);constexpr outer_iterator(Parent& parent, iterator_t<Base> current) requires ForwardRange<Base>;constexpr outer_iterator(outer_iterator<!Const> i) requires Const && ConvertibleTo<iterator_t<V>, iterator_t<const V>>;   constexpr value_type operator*()const;   constexpr outer_iterator& operator++();constexpr decltype(auto) operator++(int){ifconstexpr(ForwardRange<Base>){auto tmp =*this;++*this;return tmp;}else++*this;}   friendconstexprbool operator==(const outer_iterator& x, const outer_iterator& y) requires ForwardRange<Base>;friendconstexprbool operator!=(const outer_iterator& x, const outer_iterator& y) requires ForwardRange<Base>;   friendconstexprbool operator==(const outer_iterator& x, default_sentinel_t);friendconstexprbool operator==(default_sentinel_t, const outer_iterator& x);friendconstexprbool operator!=(const outer_iterator& x, default_sentinel_t y);friendconstexprbool operator!=(default_sentinel_t y, const outer_iterator& x);};}

クラス std::ranges::split_view::outer_iterator::value_type

namespace std::ranges{template<class V, class Pattern>template<bool Const>struct split_view<V, Pattern>::outer_iterator<Const>::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()const;};}

クラステンプレート std::ranges::split_view::inner_iterator

namespace std::ranges{template<class V, class Pattern>template<bool Const>struct split_view<V, Pattern>::inner_iterator{private:using Base = conditional_t<Const, const V, V>;// exposition only outer_iterator<Const> i_ = outer_iterator<Const>();// exposition onlybool incremented_ =false;// exposition onlypublic:using iterator_concept =typename outer_iterator<Const>::iterator_concept;using iterator_category =/* see definition */;using value_type = iter_value_t<iterator_t<Base>>;using difference_type = iter_difference_t<iterator_t<Base>>;   inner_iterator()=default;constexprexplicit inner_iterator(outer_iterator<Const> i);   constexpr decltype(auto) operator*()const{return*i_.current;}   constexpr inner_iterator& operator++();constexpr decltype(auto) operator++(int){ifconstexpr(ForwardRange<V>){auto tmp =*this;++*this;return tmp;}else++*this;}   friendconstexprbool operator==(const inner_iterator& x, const inner_iterator& y) requires ForwardRange<Base>;friendconstexprbool operator!=(const inner_iterator& x, const inner_iterator& y) requires ForwardRange<Base>;   friendconstexprbool operator==(const inner_iterator& x, default_sentinel_t);friendconstexprbool operator==(default_sentinel_t, const inner_iterator& x);friendconstexprbool operator!=(const inner_iterator& x, default_sentinel_t y);friendconstexprbool operator!=(default_sentinel_t y, const inner_iterator& x);   friendconstexpr decltype(auto) iter_move(const inner_iterator& i)noexcept(noexcept(ranges::iter_move(i.i_.current))){return ranges::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 IndirectlySwappable<iterator_t<Base>>;};}

クラステンプレート std::ranges::common_view

namespace std::ranges{template<View V> requires (!CommonRange<V>)class common_view :public view_interface<common_view<V>>{private: V base_ = V();// exposition onlypublic: common_view()=default;   constexprexplicit common_view(V r);   template<ViewableRange R> requires (!CommonRange<R>&& Constructible<V, all_view<R>>)constexprexplicit common_view(R&& r);   constexpr V base()const;   constexprauto size() requires SizedRange<V>{return ranges::size(base_);}constexprauto size()const requires SizedRange<const V>{return ranges::size(base_);}   constexprauto begin(){ifconstexpr(RandomAccessRange<V>&& SizedRange<V>)return ranges::begin(base_);elsereturn common_iterator<iterator_t<V>, sentinel_t<V>>(ranges::begin(base_));}   constexprauto begin()const requires Range<const V>{ifconstexpr(RandomAccessRange<const V>&& SizedRange<const V>)return ranges::begin(base_);elsereturn common_iterator<iterator_t<const V>, sentinel_t<const V>>(ranges::begin(base_));}   constexprauto end(){ifconstexpr(RandomAccessRange<V>&& SizedRange<V>)return ranges::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(RandomAccessRange<const V>&& SizedRange<const V>)return ranges::begin(base_)+ ranges::size(base_);elsereturn common_iterator<iterator_t<const V>, sentinel_t<const V>>(ranges::end(base_));}};   template<class R> common_view(R&&)-> common_view<all_view<R>>;}

クラステンプレート std::ranges::reverse_view

namespace std::ranges{template<View V> requires BidirectionalRange<V>class reverse_view :public view_interface<reverse_view<V>>{private: V base_ = V();// exposition onlypublic: reverse_view()=default;   constexprexplicit reverse_view(V r);   template<ViewableRange R> requires BidirectionalRange<R>&& Constructible<V, all_view<R>>constexprexplicit reverse_view(R&& r);   constexpr V base()const;   constexpr reverse_iterator<iterator_t<V>> begin();constexpr reverse_iterator<iterator_t<V>> begin() requires CommonRange<V>;constexpr reverse_iterator<iterator_t<const V>> begin()const requires CommonRange<const V>;   constexpr reverse_iterator<iterator_t<V>> end();constexpr reverse_iterator<iterator_t<const V>> end()const requires CommonRange<const V>;   constexprauto size() requires SizedRange<V>{return ranges::size(base_);}constexprauto size()const requires SizedRange<const V>{return ranges::size(base_);}};   template<class R> reverse_view(R&&)-> reverse_view<all_view<R>>;}