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*` 를 적용하여 타입이 읽을 수 있음을 명시 (concept)
Writable	반복자의 참조 객체에 값을 쓸 수 있음을 명시 (concept)
WeaklyIncrementable	`Semiregular` 타입이 전위 및 후위 증가 연산자로 증가될 수 있음을 명시 (concept)
Incrementable	`WeaklyIncrementable` 타입의 증가 연산이 동등성 보존적이며 해당 타입이 `EqualityComparable` 임을 명시 (concept)
Iterator	타입의 객체가 증가 및 역참조될 수 있음을 명시 (concept)
Sentinel	타입의 객체가 `Iterator` 타입에 대한 센티넬임을 명시 (concept)
SizedSentinel	`-` 연산자를 반복자와 센티넬에 적용하여 상수 시간에 차이를 계산할 수 있음을 명시 (concept)
InputIterator	타입이 입력 반복자임을 명시, 즉 참조 값이 읽을 수 있고 전위 및 후위 증가가 가능함 (concept)
OutputIterator	타입이 주어진 값 타입에 대한 출력 반복자임을 명시, 즉 해당 타입의 값이 쓰일 수 있고 전위 및 후위 증가가 가능함 (concept)
ForwardIterator	`InputIterator` 가 전방 반복자임을 명시, 동등 비교 및 다중 패스를 지원함 (concept)
BidirectionalIterator	`ForwardIterator` 가 양방향 반복자임을 명시, 역방향 이동을 지원함 (concept)
RandomAccessIterator	`BidirectionalIterator` 가 임의 접근 반복자임을 명시, 상수 시간 이동 및 첨자 연산을 지원함 (concept)

간접 호출 가능 개념

IndirectUnaryInvocable IndirectRegularUnaryInvocable	호출 가능 타입이 `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	두 개의 `Readable` 타입이 참조하는 값들이 교환될 수 있음을 명시 (concept)
IndirectlyComparable	두 개의 `Readable` 타입이 참조하는 값들이 비교될 수 있음을 명시 (concept)
Permutable	제자리에서 요소들을 재정렬하는 알고리즘들의 공통 요구사항을 명시 (concept)
Mergeable	요소들을 복사하여 정렬된 시퀀스들을 출력 시퀀스로 병합하는 알고리즘들의 요구사항을 명시 (concept)
Sortable	시퀀스들을 정렬된 시퀀스로 순열 변경하는 알고리즘들의 공통 요구사항을 명시 (concept)

개념 유틸리티

indirect_result_of	일부 `Readable` 타입들을 역참조한 결과에 호출 가능 객체를 적용한 결과를 계산함 (클래스 템플릿)
projected	프로젝션을 받아들이는 알고리즘들의 제약 조건을 지정하기 위한 도우미 템플릿 (클래스 템플릿)

반복자 기본 요소

반복자 유틸리티

다음 네임스페이스에 정의됨 `std::experimental::ranges`
iter_move	객체를 역참조한 결과를 해당 rvalue 참조 타입으로 변환 (customization point object)
iter_swap	두 개의 역참조 가능 객체가 참조하는 값을 교환 (customization point object)

반복자 특성

다음 네임스페이스에 정의됨 `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	역참조 시 rvalue 참조를 반환하는 반복자 어댑터 (클래스 템플릿)
move_sentinel	`move_iterator` 와 함께 사용하기 위한 센티넬 어댑터 (클래스 템플릿)
common_iterator	레거시 알고리즘과 함께 사용하기 위해 반복자-센티넬 쌍을 공통 반복자 타입으로 적응 (클래스 템플릿)
counted_iterator	시작 위치로부터의 거리를 추적하는 반복자 어댑터 (클래스 템플릿)
default_sentinel	자신의 범위 경계를 아는 반복자 타입과 함께 사용하기 위한 빈 센티넬 타입 (클래스)
dangling	댕글링(dangling) 가능성이 있는 반복자를 위한 래퍼 (클래스 템플릿)
safe_iterator_t	rvalue 범위의 반복자 타입을 `dangling` 으로 래핑하는 별칭 템플릿 (별칭 템플릿)
unreachable	무한 범위를 나타내기 위해 모든 반복자와 함께 사용되는 센티넬 타입 (클래스)

스트림 반복자

정의된 네임스페이스 `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>

목차

반복자 관련 개념

반복자 개념

간접 호출 가능 개념

공통 알고리즘 요구사항

개념 유틸리티

반복자 기본 요소

반복자 유틸리티

반복자 특성

반복자 범주 태그

std::iterator_traits 특수화

반복자 연산

반복자 어댑터

스트림 반복자

시놉시스