Experimental library header <experimental/ranges/iterator>

From cppreference.net

<experimental/execution>

Filesystem TS

<experimental/filesystem>

Parallelism TS (v1, v2)

`experimental/algorithm`
`experimental/execution_policy`
`experimental/exception_list`

`experimental/numeric`
`<experimental/simd>`
`experimental/task_block`

Library Fundamentals 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`

Concurrency 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>`

Coroutines TS


               experimental/coroutine

Networking TS

`experimental/buffer`
`experimental/executor`
`experimental/internet`
`experimental/io_context`

`<experimental/net>`
`experimental/netfwd`
`experimental/socket`
`experimental/timer`

Reflection TS

<experimental/reflect>

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

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

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

IndirectUnaryInvocable IndirectRegularUnaryInvocable	呼び出し可能型が `Readable` 型の間接参照結果で呼び出し可能であることを指定する (コンセプト)
IndirectUnaryPredicate	呼び出し可能オブジェクトが、 `Readable` 型の間接参照結果で呼び出されたときに `Predicate` を満たすことを指定する (コンセプト)
IndirectRelation	呼び出し可能オブジェクトが、いくつかの `Readable` 型の間接参照結果で呼び出されたときに `Relation` を満たすことを指定する (コンセプト)
IndirectStrictWeakOrder	呼び出し可能オブジェクトが、いくつかの `Readable` 型の間接参照結果で呼び出されたときに `StrictWeakOrder` を満たすことを指定する (コンセプト)

共通アルゴリズム要件

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

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

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

イテレータ基本要素

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

名前空間 `std::experimental::ranges` で定義
iter_move	オブジェクトを間接参照した結果を、関連する右辺値参照型にキャストする (カスタマイゼーションポイントオブジェクト)
iter_swap	二つの間接参照可能なオブジェクトが参照する値を交換する (カスタマイゼーションポイントオブジェクト)

イテレータ特性

名前空間 `std::experimental::ranges` で定義
difference_type	`WeaklyIncrementable` 型の差型を取得する (クラステンプレート)
value_type	`Readable` 型の値型を取得する (クラステンプレート)
iterator_category	入力イテレータ型のイテレータカテゴリを取得する (クラステンプレート)
iterator_traits	イテレータの関連型を収集する互換性トレイトクラス (エイリアステンプレート)
reference_t rvalue_reference_t iter_common_reference_t	間接参照可能オブジェクトの関連参照型を取得する (エイリアステンプレート)

イテレータカテゴリタグ

名前空間で定義 `std::experimental::ranges`
input_iterator_tag output_iterator_tag forward_iterator_tag bidirectional_iterator_tag random_access_iterator_tag	イテレータカテゴリを示すために使用される空のクラス型 (クラス)

std::iterator_traits 特殊化

名前空間 `std` で定義
std::iterator_traits <InputIterator> std::iterator_traits <OutputIterator>	ranges TSイテレータに対する std::iterator_traits の特殊化 (クラステンプレートの特殊化)

イテレータ操作

名前空間で定義 `std::experimental::ranges`
advance	イテレータを指定された距離だけ進める (関数テンプレート)
distance	イテレータとセンチネル間、または範囲の先頭と終端間の距離を返す (関数テンプレート)
next	イテレータをインクリメントする (関数テンプレート)
prev	イテレータをデクリメントする (関数テンプレート)

イテレータアダプタ

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

ストリームイテレータ

namespace `std::experimental::ranges` で定義
istream_iterator	std::basic_istream から読み込む入力イテレータ (クラステンプレート)
ostream_iterator	std::basic_ostream に書き込む出力イテレータ (クラステンプレート)
istreambuf_iterator	std::basic_streambuf から読み込む入力イテレータ (クラステンプレート)
ostreambuf_iterator	std::basic_streambuf に書き込む出力イテレータ (クラステンプレート)

概要

namespace std { namespace experimental { namespace ranges { inline namespace v1 {
template <class T> concept bool /* デリファレンス可能 */ // 説明専用
  = requires(T& t) { {*t} -> auto&&; };
namespace {
  constexpr /* 未指定 */ iter_move = /* 未指定 */;
  constexpr /* 未指定 */ iter_swap = /* 未指定 */;
}
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 </* デリファレンス可能 */ T> using reference_t
  = decltype(*declval<T&>());
template </* デリファレンス可能 */ T>
    requires /* 定義を参照 */ using rvalue_reference_t
  = decltype(ranges::iter_move(declval<T&>()));
template <class In>
concept bool Readable = /* 定義を参照 */;
template <class Out, class T>
concept bool Writable = /* 定義を参照 */;
template <class I>
concept bool WeaklyIncrementable = /* 定義を参照 */;
template <class I>
concept bool Incrementable = /* 定義を参照 */;
template <class I>
concept bool Iterator = /* 定義を参照 */;
template <class S, class I>
concept bool Sentinel = /* 定義を参照 */;
template <class S, class I>
  constexpr bool disable_sized_sentinel = false;
template <class S, class I>
concept bool SizedSentinel = /* 定義を参照 */;
template <class I>
concept bool InputIterator = /* 定義を参照 */;
template <class I>
concept bool OutputIterator = /* 定義を参照 */;
template <class I>
concept bool ForwardIterator = /* 定義を参照 */;
template <class I>
concept bool BidirectionalIterator = /* 定義を参照 */;
template <class I>
concept bool RandomAccessIterator = /* 定義を参照 */;
template <class F, class I>
concept bool IndirectUnaryInvocable = /* 定義を参照 */;
template <class F, class I>
concept bool IndirectRegularUnaryInvocable = /* 定義を参照 */;
template <class F, class I>
concept bool IndirectUnaryPredicate = /* 定義を参照 */;
template <class F, class I1, class I2 = I1>
concept bool IndirectRelation = /* 定義を参照 */;
template <class F, class I1, class I2 = I1>
concept bool IndirectStrictWeakOrder = /* 定義を参照 */;
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 = /* 定義を参照 */;
template <class In, class Out>
concept bool IndirectlyMovableStorable = /* 定義を参照 */;
template <class In, class Out>
concept bool IndirectlyCopyable = /* 定義を参照 */;
template <class In, class Out>
concept bool IndirectlyCopyableStorable = /* 定義を参照 */;
template <class I1, class I2 = I1>
concept bool IndirectlySwappable = /* 定義を参照 */;
template <class I1, class I2, class R = equal_to<>, class P1 = identity,
    class P2 = identity>
concept bool IndirectlyComparable = /* 定義を参照 */;
template <class I>
concept bool Permutable = /* 定義を参照 */;
template <class I1, class I2, class Out,
    class R = less<>, class P1 = identity, class P2 = identity>
concept bool Mergeable = /* 定義を参照 */;
template <class I, class R = less<>, class P = identity>
concept bool Sortable = /* 定義を参照 */;
template <class Iterator> using iterator_traits = /* 定義を参照 */;
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 /* 未指定 */ advance = /* 未指定 */;
  constexpr /* 未指定 */ distance = /* 未指定 */;
  constexpr /* 未指定 */ next = /* 未指定 */;
  constexpr /* 未指定 */ prev = /* 未指定 */;
}
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;
}

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Diagnostics library
Memory management library
Metaprogramming library (C++11)
General utilities library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Strings library
Text processing library
Numerics library
Date and time library
Input/output library
Filesystem library (C++17)
Concurrency support library (C++11)
Execution control library (C++26)
Technical specifications
Symbols index
External libraries

cppreference.net

Namespaces

Variants

Experimental library header <experimental/ranges/iterator>

目次

イテレータ関連の概念

Iterator コンセプト

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

共通アルゴリズム要件

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

イテレータ基本要素

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

イテレータ特性

イテレータカテゴリタグ

std::iterator_traits 特殊化

イテレータ操作

イテレータアダプタ

ストリームイテレータ

概要