実験的ライブラリヘッダー <experimental/ranges/iterator>

 

C++

コンパイラサポート

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

言語

標準ライブラリ

標準ライブラリヘッダー

名前付き要件

機能テストマクロ (C++20)

言語サポートライブラリ

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

診断ライブラリ

メモリ管理ライブラリ

メタプログラミングライブラリ (C++11)

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

コンテナライブラリ

イテレータライブラリ

Rangesライブラリ (C++20)

アルゴリズムライブラリ

文字列ライブラリ

テキスト処理ライブラリ

数値ライブラリ

日付と時刻ライブラリ

入出力ライブラリ

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

並行サポートライブラリ (C++11)

実行制御ライブラリ (C++26)

Technical specifications (技術仕様)

シンボルインデックス

外部ライブラリ

 

標準ライブラリヘッダー

言語サポート <cfloat> <climits> <compare> (C++20) <contracts> (C++26) <coroutine> (C++20) <csetjmp> <csignal> <cstdarg> <cstddef> <cstdint> (C++11) <cstdlib> <exception> <initializer_list> (C++11)    <limits> <new> <source_location> (C++20) <stdfloat> (C++23) <typeinfo> <version> (C++20) コンセプト <concepts> (C++20) 診断 <cassert> <cerrno> <debugging> (C++26) <stacktrace> (C++23) <stdexcept> <system_error> (C++11) メモリ管理 <memory> <memory_resource> (C++17) <scoped_allocator> (C++11) メタプログラミング <type_traits> (C++11) <ratio> (C++11)

汎用ユーティリティ <any> (C++17) <bitset> <bit> (C++20) <charconv> (C++17) <expected> (C++23) <format> (C++20) <functional> <optional> (C++17) <tuple> (C++11) <typeindex> (C++11) <utility> <variant> (C++17) コンテナ <array> (C++11) <deque> <flat_map> (C++23) <flat_set> (C++23) <forward_list> (C++11) <hive> (C++26) <inplace_vector> (C++26)    <list> <map> <mdspan> (C++23) <queue> <set> <span> (C++20) <stack> <unordered_map> (C++11) <unordered_set> (C++11) <vector> イテレータ <iterator> Ranges <generator> (C++23) <ranges> (C++20)

アルゴリズム <algorithm> <numeric> 文字列 <cctype> <cstring> <cuchar> (C++11) <cwchar> <cwctype> <string_view> (C++17) <string> テキスト処理 <clocale> <codecvt> (C++11/17/26*) <locale> <regex> (C++11) <text_encoding> (C++26)    数値 <cfenv> (C++11) <cmath> <complex> <linalg> (C++26) <numbers> (C++20) <random> (C++11) <simd> (C++26) <valarray> 時間 <chrono> (C++11) <ctime> C互換 <ccomplex> (C++11/17/20*) <ciso646> (C++20 まで) <cstdalign> (C++11/17/20*) <cstdbool> (C++11/17/20*) <ctgmath> (C++11/17/20*)

入出力 <cinttypes> (C++11) <cstdio> <filesystem> (C++17) <fstream> <iomanip> <iosfwd> <iostream> <ios> <istream> <ostream> <print> (C++23) <spanstream> (C++23) <sstream> <streambuf> <strstream> (C++98/26*) <syncstream> (C++20) 並行性サポート <atomic> (C++11) <barrier> (C++20) <condition_variable> (C++11) <future> (C++11) <hazard_pointer> (C++26) <latch> (C++20) <mutex> (C++11) <rcu> (C++26) <semaphore> (C++20) <shared_mutex> (C++14) <stdatomic.h> (C++23) <stop_token> (C++20) <thread> (C++11) 実行サポート <execution> (C++17)

 

実験的なライブラリヘッダー

実行 P2300
<experimental/execution>
ファイルシステム TS
<experimental/filesystem>
並列処理 TS (v1, v2)
experimental/algorithm experimental/execution_policy experimental/exception_list	experimental/numeric <experimental/simd> experimental/task_block
ライブラリの基礎 TS (v1, v2, v3)
experimental/algorithm <experimental/any> experimental/array experimental/chrono experimental/deque experimental/forward_list <experimental/functional> experimental/future experimental/iterator experimental/list experimental/map experimental/memory <experimental/memory_resource> experimental/numeric <experimental/optional> experimental/propagate_const	experimental/random experimental/ratio experimental/regex experimental/scope experimental/set experimental/source_location experimental/string <experimental/string_view> experimental/system_error experimental/tuple experimental/type_traits experimental/unordered_map experimental/unordered_set experimental/utility experimental/vector
並行処理 TS
experimental/atomic experimental/barrier	experimental/future experimental/latch
Ranges TS
<experimental/ranges/algorithm> <experimental/ranges/concepts> <experimental/ranges/functional>         <experimental/ranges/iterator>	<experimental/ranges/random> <experimental/ranges/tuple> <experimental/ranges/type_traits> <experimental/ranges/utility>
コルーチンTS
experimental/coroutine
ネットワーキングTS
experimental/buffer experimental/executor experimental/internet experimental/io_context	<experimental/net> experimental/netfwd experimental/socket experimental/timer
リフレクションTS
<experimental/reflect>

 

このヘッダーは、ranges ライブラリの一部です。

イテレータ関連コンセプト

std::experimental::ranges 名前空間で定義されます。

イテレータコンセプト

Readable	演算子 * を適用することで読み取り可能であることを指定します。 (concept)
Writable	イテレータが参照するオブジェクトに値を書き込めることを規定する (concept)
WeaklyIncrementable	Semiregular 型が前置および後置インクリメント演算子でインクリメントできることを指定します。 (concept)
Incrementable	WeaklyIncrementable 型のインクリメント操作が等価性を保持し、その型がEqualityComparableであることを指定します。 (concept)
イテレータ	ある型のオブジェクトがインクリメントおよび間接参照できることを規定する (concept)
Sentinel	Iterator 型のセンチネルであることを指定します。 (concept)
SizedSentinel	イテレータとセンチネルに-演算子を適用して、それらの差を定数時間で計算できることを指定します。 (concept)
InputIterator	型が入力イテレータであること、すなわち、参照先の値を読み取ることができ、前置および後置インクリメントの両方が可能であることを規定する (concept)
OutputIterator	型が与えられた値型に対する出力イテレータであること、すなわち、その型の値を書き込むことができ、前置および後置インクリメントの両方が可能であることを規定する (concept)
ForwardIterator	InputIteratorがフォワードイテレータであり、等価比較と複数パスをサポートすることを指定します。 (concept)
BidirectionalIterator	ForwardIteratorが双方向イテレータであり、後方移動をサポートすることを指定します。 (concept)
RandomAccessIterator	BidirectionalIteratorがランダムアクセスイテレータであり、定数時間での前進と添え字アクセスをサポートすることを指定します。 (concept)

間接呼び出し可能コンセプト

IndirectUnaryInvocableIndirectRegularUnaryInvocable	Readable型のデリファレンス結果で呼び出し可能型を呼び出せることを指定します。 (concept)
IndirectUnaryPredicate	Readable型のデリファレンス結果で呼び出された呼び出し可能オブジェクトがPredicateを満たすことを指定します。 (concept)
IndirectRelation	いくつかのReadable型のデリファレンス結果で呼び出された呼び出し可能オブジェクトがRelationを満たすことを指定します。 (concept)
IndirectStrictWeakOrder	いくつかのReadable型のデリファレンス結果で呼び出された呼び出し可能オブジェクトがStrictWeakOrderを満たすことを指定します。 (concept)

共通アルゴリズム要件

IndirectlyMovable	Readable型からWritable型へ値を移動できることを指定します。 (concept)
IndirectlyMovableStorable	Readable型からWritable型へ値を移動でき、その移動が中間オブジェクトを介して行われる可能性があることを指定します。 (concept)
IndirectlyCopyable	Readable型からWritable型へ値をコピーできることを指定します。 (concept)
IndirectlyCopyableStorable	Readable型からWritable型へ値をコピーでき、そのコピーが中間オブジェクトを介して行われる可能性があることを指定します。 (concept)
IndirectlySwappable	2つのReadable型によって参照される値を交換できることを指定します。 (concept)
IndirectlyComparable	2つのReadable型によって参照される値を比較できることを指定します。 (concept)
Permutable	要素をインプレースで並べ替えるアルゴリズムの共通要件を規定する (concept)
Mergeable	ソート済みのシーケンスを要素をコピーして出力シーケンスにマージするアルゴリズムの要件を規定する (concept)
Sortable	シーケンスを順序付きシーケンスに並べ替えるアルゴリズムの共通要件を規定する (concept)

コンセプトユーティリティ

indirect_result_of	いくつかのReadable型のデリファレンス結果を呼び出し可能オブジェクトで呼び出した結果を計算します。 (class template)
projected	射影を受け入れるアルゴリズムの制約を指定するためのヘルパーテンプレート (class template)

イテレータプリミティブ

イテレータユーティリティ

std::experimental::ranges 名前空間で定義されます。
iter_move	オブジェクトの間接参照の結果を、その関連する右辺値参照型にキャストする (customization point object)
iter_swap	2つのデリファレンス可能なオブジェクトによって参照される値を交換します。 (customization point object)

イテレータトレイト

std::experimental::ranges 名前空間で定義されます。
difference_type	WeaklyIncrementable型の差分型を取得します。 (class template)
value_type	Readable型の値型を取得します。 (class template)
iterator_category	入力イテレータ型のイテレータカテゴリを取得します。 (class template)
iterator_traits	イテレータの関連型を収集する互換性トレイトクラス。 (alias template)
reference_trvalue_reference_titer_common_reference_t	デリファレンス可能なオブジェクトに関連付けられた参照型を取得します。 (alias template)

イテレータカテゴリタグ

std::experimental::ranges 名前空間で定義されます。
input_iterator_tagoutput_iterator_tagforward_iterator_tagbidirectional_iterator_tagrandom_access_iterator_tag	イテレータカテゴリを示すために使用される空のクラス型 (class)

std::iterator_traits の特殊化

名前空間 std で定義
std::iterator_traits<InputIterator>std::iterator_traits<OutputIterator>	ranges TSイテレータのstd::iterator_traitsを特殊化します。 (class template specialization)

イテレータ操作

std::experimental::ranges 名前空間で定義されます。
advance	イテレータを指定された距離だけ進める (function template)
distance	イテレータとセンチネルの間の距離、または範囲の開始と終了の間の距離を返します。 (function template)
next	イテレータをインクリメントする (function template)
prev	イテレータをデクリメントする (function template)

イテレータアダプタ

std::experimental::ranges 名前空間で定義されます。
reverse_iterator	逆順走査のためのイテレータアダプタ (class template)
back_insert_iterator	コンテナの末尾への挿入のためのイテレータアダプタ (class template)
front_insert_iterator	コンテナの先頭への挿入のためのイテレータアダプタ (class template)
insert_iterator	コンテナへの挿入のためのイテレータアダプタ (class template)
move_iterator	rvalue参照にデリファレンスするイテレータアダプタ。 (class template)
move_sentinel	move_iteratorと併用するためのセンチネルアダプタ。 (class template)
common_iterator	レガシーアルゴリズムで使用するために、イテレータとセンチネルのペアを共通のイテレータ型にアダプタします。 (class template)
counted_iterator	開始位置からの距離を追跡するイテレータアダプタ。 (class template)
default_sentinel	範囲の境界を知っているイテレータ型と併用するための空のセンチネル型。 (class)
dangling	ぶら下がっている可能性のあるイテレータのラッパー。 (class template)
safe_iterator_t	rvalue範囲のイテレータ型をdanglingでラップするエイリアステンプレート。 (alias template)
unreachable	無限範囲を示すために任意のイテレータと併用されるセンチネル型。 (class)

ストリームイテレータ

std::experimental::ranges 名前空間で定義されます。
istream_iterator	std::basic_istream から読み取る入力イテレータ (class template)
ostream_iterator	std::basic_ostream に書き込む出力イテレータ (class template)
istreambuf_iterator	std::basic_streambuf から読み取る入力イテレータ (class template)
ostreambuf_iterator	std::basic_streambuf に書き込む出力イテレータ (class template)

シノプシス

namespace std { namespace experimental { namespace ranges { inline namespace v1 {
 
template <class T> concept bool /* dereferenceable */ // exposition only
  = requires(T& t) { {*t} -> auto&&; };
 
namespace {
  constexpr /* unspecified */ iter_move = /* unspecified */;
  constexpr /* unspecified */ iter_swap = /* unspecified */;
}
 
template <class> struct difference_type;
template <class T> using difference_type_t
  = typename difference_type<T>::type;
 
template <class> struct value_type;
template <class T> using value_type_t
  = typename value_type<T>::type;
 
template <class> struct iterator_category;
template <class T> using iterator_category_t
  = typename iterator_category<T>::type;
 
template </* dereferenceable */ T> using reference_t
  = decltype(*declval<T&>());
 
template </* dereferenceable */ T>
    requires /* see definition */ using rvalue_reference_t
  = decltype(ranges::iter_move(declval<T&>()));
 
template <class In>
concept bool Readable = /* see definition */;
 
template <class Out, class T>
concept bool Writable = /* see definition */;
 
template <class I>
concept bool WeaklyIncrementable = /* see definition */;
 
template <class I>
concept bool Incrementable = /* see definition */;
 
template <class I>
concept bool Iterator = /* see definition */;
 
template <class S, class I>
concept bool Sentinel = /* see definition */;
 
template <class S, class I>
  constexpr bool disable_sized_sentinel = false;
 
template <class S, class I>
concept bool SizedSentinel = /* see definition */;
 
template <class I>
concept bool InputIterator = /* see definition */;
 
template <class I>
concept bool OutputIterator = /* see definition */;
 
template <class I>
concept bool ForwardIterator = /* see definition */;
 
template <class I>
concept bool BidirectionalIterator = /* see definition */;
 
template <class I>
concept bool RandomAccessIterator = /* see definition */;
 
template <class F, class I>
concept bool IndirectUnaryInvocable = /* see definition */;
 
template <class F, class I>
concept bool IndirectRegularUnaryInvocable = /* see definition */;
 
template <class F, class I>
concept bool IndirectUnaryPredicate = /* see definition */;
 
template <class F, class I1, class I2 = I1>
concept bool IndirectRelation = /* see definition */;
 
template <class F, class I1, class I2 = I1>
concept bool IndirectStrictWeakOrder = /* see definition */;
 
template <class> struct indirect_result_of;
 
template <class F, class... Is>
  requires Invocable<F, reference_t<Is>...>
struct indirect_result_of<F(Is...)>;
 
template <class F>
using indirect_result_of_t
  = typename indirect_result_of<F>::type;
 
template <Readable I, IndirectRegularUnaryInvocable<I> Proj>
struct projected;
 
template <WeaklyIncrementable I, class Proj>
struct difference_type<projected<I, Proj>>;
 
template <class In, class Out>
concept bool IndirectlyMovable = /* see definition */;
 
template <class In, class Out>
concept bool IndirectlyMovableStorable = /* see definition */;
 
template <class In, class Out>
concept bool IndirectlyCopyable = /* see definition */;
 
template <class In, class Out>
concept bool IndirectlyCopyableStorable = /* see definition */;
 
template <class I1, class I2 = I1>
concept bool IndirectlySwappable = /* see definition */;
 
template <class I1, class I2, class R = equal_to<>, class P1 = identity,
    class P2 = identity>
concept bool IndirectlyComparable = /* see definition */;
 
template <class I>
concept bool Permutable = /* see definition */;
 
template <class I1, class I2, class Out,
    class R = less<>, class P1 = identity, class P2 = identity>
concept bool Mergeable = /* see definition */;
 
template <class I, class R = less<>, class P = identity>
concept bool Sortable = /* see definition */;
 
template <class Iterator> using iterator_traits = /* see definition */;
 
template <Readable T> using iter_common_reference_t
  = common_reference_t<reference_t<T>, value_type_t<T>&>;
 
struct output_iterator_tag { };
struct input_iterator_tag { };
struct forward_iterator_tag : input_iterator_tag { };
struct bidirectional_iterator_tag : forward_iterator_tag { };
struct random_access_iterator_tag : bidirectional_iterator_tag { };
 
namespace {
  constexpr /* unspecified */ advance = /* unspecified */;
  constexpr /* unspecified */ distance = /* unspecified */;
  constexpr /* unspecified */ next = /* unspecified */;
  constexpr /* unspecified */ prev = /* unspecified */;
}
 
template <BidirectionalIterator I> class reverse_iterator;
 
template <class I1, class I2>
    requires EqualityComparableWith<I1, I2>
  constexpr bool operator==(
    const reverse_iterator<I1>& x,
    const reverse_iterator<I2>& y);
template <class I1, class I2>
    requires EqualityComparableWith<I1, I2>
  constexpr bool operator!=(
    const reverse_iterator<I1>& x,
    const reverse_iterator<I2>& y);
template <class I1, class I2>
    requires StrictTotallyOrderedWith<I1, I2>
  constexpr bool operator<(
    const reverse_iterator<I1>& x,
    const reverse_iterator<I2>& y);
template <class I1, class I2>
    requires StrictTotallyOrderedWith<I1, I2>
  constexpr bool operator>(
    const reverse_iterator<I1>& x,
    const reverse_iterator<I2>& y);
template <class I1, class I2>
    requires StrictTotallyOrderedWith<I1, I2>
  constexpr bool operator>=(
    const reverse_iterator<I1>& x,
    const reverse_iterator<I2>& y);
template <class I1, class I2>
    requires StrictTotallyOrderedWith<I1, I2>
  constexpr bool operator<=(
    const reverse_iterator<I1>& x,
    const reverse_iterator<I2>& y);
 
template <class I1, class I2>
    requires SizedSentinel<I1, I2>
  constexpr difference_type_t<I2> operator-(
    const reverse_iterator<I1>& x,
    const reverse_iterator<I2>& y);
template <RandomAccessIterator I>
  constexpr reverse_iterator<I> operator+(
    difference_type_t<I> n,
    const reverse_iterator<I>& x);
 
template <BidirectionalIterator I>
constexpr reverse_iterator<I> make_reverse_iterator(I i);
 
template <class Container> class back_insert_iterator;
template <class Container>
  back_insert_iterator<Container> back_inserter(Container& x);
 
template <class Container> class front_insert_iterator;
template <class Container>
  front_insert_iterator<Container> front_inserter(Container& x);
 
template <class Container> class insert_iterator;
template <class Container>
  insert_iterator<Container> inserter(Container& x, iterator_t<Container> i);
 
template <InputIterator I> class move_iterator;
 
template <class I1, class I2>
    requires EqualityComparableWith<I1, I2>
  constexpr bool operator==(
    const move_iterator<I1>& x, const move_iterator<I2>& y);
template <class I1, class I2>
    requires EqualityComparableWith<I1, I2>
  constexpr bool operator!=(
    const move_iterator<I1>& x, const move_iterator<I2>& y);
template <class I1, class I2>
    requires StrictTotallyOrderedWith<I1, I2>
  constexpr bool operator<(
    const move_iterator<I1>& x, const move_iterator<I2>& y);
template <class I1, class I2>
    requires StrictTotallyOrderedWith<I1, I2>
  constexpr bool operator<=(
    const move_iterator<I1>& x, const move_iterator<I2>& y);
template <class I1, class I2>
    requires StrictTotallyOrderedWith<I1, I2>
  constexpr bool operator>(
    const move_iterator<I1>& x, const move_iterator<I2>& y);
template <class I1, class I2>
    requires StrictTotallyOrderedWith<I1, I2>
  constexpr bool operator>=(
    const move_iterator<I1>& x, const move_iterator<I2>& y);
 
template <class I1, class I2>
    requires SizedSentinel<I1, I2>
  constexpr difference_type_t<I2> operator-(
    const move_iterator<I1>& x,
    const move_iterator<I2>& y);
template <RandomAccessIterator I>
  constexpr move_iterator<I> operator+(
    difference_type_t<I> n,
    const move_iterator<I>& x);
 
template <InputIterator I>
  constexpr move_iterator<I> make_move_iterator(I i);
 
template <Semiregular S> class move_sentinel;
 
template <class I, Sentinel<I> S>
  constexpr bool operator==(
    const move_iterator<I>& i, const move_sentinel<S>& s);
template <class I, Sentinel<I> S>
  constexpr bool operator==(
    const move_sentinel<S>& s, const move_iterator<I>& i);
template <class I, Sentinel<I> S>
  constexpr bool operator!=(
    const move_iterator<I>& i, const move_sentinel<S>& s);
template <class I, Sentinel<I> S>
  constexpr bool operator!=(
    const move_sentinel<S>& s, const move_iterator<I>& i);
 
template <class I, SizedSentinel<I> S>
  constexpr difference_type_t<I> operator-(
    const move_sentinel<S>& s, const move_iterator<I>& i);
template <class I, SizedSentinel<I> S>
  constexpr difference_type_t<I> operator-(
    const move_iterator<I>& i, const move_sentinel<S>& s);
 
template <Semiregular S>
  constexpr move_sentinel<S> make_move_sentinel(S s);
 
template <Iterator I, Sentinel<I> S>
  requires !Same<I, S>
class common_iterator;
 
template <Readable I, class S>
struct value_type<common_iterator<I, S>>;
 
template <InputIterator I, class S>
struct iterator_category<common_iterator<I, S>>;
 
template <ForwardIterator I, class S>
struct iterator_category<common_iterator<I, S>>;
 
template <class I1, class I2, Sentinel<I2> S1, Sentinel<I1> S2>
bool operator==(
  const common_iterator<I1, S1>& x, const common_iterator<I2, S2>& y);
template <class I1, class I2, Sentinel<I2> S1, Sentinel<I1> S2>
  requires EqualityComparableWith<I1, I2>
bool operator==(
  const common_iterator<I1, S1>& x, const common_iterator<I2, S2>& y);
template <class I1, class I2, Sentinel<I2> S1, Sentinel<I1> S2>
bool operator!=(
  const common_iterator<I1, S1>& x, const common_iterator<I2, S2>& y);
 
template <class I2, SizedSentinel<I2> I1, SizedSentinel<I2> S1, SizedSentinel<I1> S2>
difference_type_t<I2> operator-(
  const common_iterator<I1, S1>& x, const common_iterator<I2, S2>& y);
 
class default_sentinel;
 
template <Iterator I> class counted_iterator;
 
template <class I1, class I2>
    requires Common<I1, I2>
  constexpr bool operator==(
    const counted_iterator<I1>& x, const counted_iterator<I2>& y);
constexpr bool operator==(
  const counted_iterator<auto>& x, default_sentinel);
constexpr bool operator==(
  default_sentinel, const counted_iterator<auto>& x);
template <class I1, class I2>
    requires Common<I1, I2>
  constexpr bool operator!=(
    const counted_iterator<I1>& x, const counted_iterator<I2>& y);
constexpr bool operator!=(
  const counted_iterator<auto>& x, default_sentinel y);
constexpr bool operator!=(
  default_sentinel x, const counted_iterator<auto>& y);
template <class I1, class I2>
    requires Common<I1, I2>
  constexpr bool operator<(
    const counted_iterator<I1>& x, const counted_iterator<I2>& y);
template <class I1, class I2>
    requires Common<I1, I2>
  constexpr bool operator<=(
    const counted_iterator<I1>& x, const counted_iterator<I2>& y);
template <class I1, class I2>
    requires Common<I1, I2>
  constexpr bool operator>(
    const counted_iterator<I1>& x, const counted_iterator<I2>& y);
template <class I1, class I2>
    requires Common<I1, I2>
  constexpr bool operator>=(
    const counted_iterator<I1>& x, const counted_iterator<I2>& y);
 
template <class I1, class I2>
    requires Common<I1, I2>
  constexpr difference_type_t<I2> operator-(
    const counted_iterator<I1>& x, const counted_iterator<I2>& y);
template <class I>
  constexpr difference_type_t<I> operator-(
    const counted_iterator<I>& x, default_sentinel y);
template <class I>
  constexpr difference_type_t<I> operator-(
    default_sentinel x, const counted_iterator<I>& y);
template <RandomAccessIterator I>
  constexpr counted_iterator<I>
    operator+(difference_type_t<I> n, const counted_iterator<I>& x);
 
template <Iterator I>
  constexpr counted_iterator<I> make_counted_iterator(I i, difference_type_t<I> n);
 
class unreachable;
template <Iterator I>
  constexpr bool operator==(const I&, unreachable) noexcept;
template <Iterator I>
  constexpr bool operator==(unreachable, const I&) noexcept;
template <Iterator I>
  constexpr bool operator!=(const I&, unreachable) noexcept;
template <Iterator I>
  constexpr bool operator!=(unreachable, const I&) noexcept;
 
template <class T> class dangling;
 
template <class T, class CharT = char, class Traits = char_traits<CharT>,
    class Distance = ptrdiff_t>
  class istream_iterator;
 
template <class T, class CharT, class Traits, class Distance>
  bool operator==(const istream_iterator<T, CharT, Traits, Distance>& x,
    const istream_iterator<T, CharT, Traits, Distance>& y);
template <class T, class CharT, class Traits, class Distance>
  bool operator==(default_sentinel x,
    const istream_iterator<T, CharT, Traits, Distance>& y);
template <class T, class CharT, class Traits, class Distance>
  bool operator==(const istream_iterator<T, CharT, Traits, Distance>& x,
    default_sentinel y);
template <class T, class CharT, class Traits, class Distance>
  bool operator!=(const istream_iterator<T, CharT, Traits, Distance>& x,
    const istream_iterator<T, CharT, Traits, Distance>& y);
template <class T, class CharT, class Traits, class Distance>
  bool operator!=(default_sentinel x,
    const istream_iterator<T, CharT, Traits, Distance>& y);
template <class T, class CharT, class Traits, class Distance>
  bool operator!=(const istream_iterator<T, CharT, Traits, Distance>& x,
    default_sentinel y);
 
template <class T, class CharT = char, class Traits = char_traits<CharT>>
  class ostream_iterator;
 
template <class CharT, class Traits = char_traits<CharT> >
  class istreambuf_iterator;
 
template <class CharT, class Traits>
  bool operator==(const istreambuf_iterator<CharT, Traits>& a,
    const istreambuf_iterator<CharT, Traits>& b);
template <class CharT, class Traits>
  bool operator==(default_sentinel a,
    const istreambuf_iterator<CharT, Traits>& b);
template <class CharT, class Traits>
  bool operator==(const istreambuf_iterator<CharT, Traits>& a,
    default_sentinel b);
template <class CharT, class Traits>
  bool operator!=(const istreambuf_iterator<CharT, Traits>& a,
    const istreambuf_iterator<CharT, Traits>& b);
template <class CharT, class Traits>
  bool operator!=(default_sentinel a,
    const istreambuf_iterator<CharT, Traits>& b);
template <class CharT, class Traits>
  bool operator!=(const istreambuf_iterator<CharT, Traits>& a,
    default_sentinel b);
 
template <class CharT, class Traits = char_traits<CharT> >
  class ostreambuf_iterator;
 
}}}}
 
namespace std {
  template <experimental::ranges::Iterator Out>
    struct iterator_traits<Out>;
  template <experimental::ranges::InputIterator In>
    struct iterator_traits<In>;
  template <experimental::ranges::InputIterator In>
      requires experimental::ranges::Sentinel<In, In>
    struct iterator_traits;
}