Namespaces
Variants

Standard library header <iterator>

From cppreference.net
C++
Standard library headers

이 헤더는 iterator 라이브러리의 일부입니다.

이 헤더는 부분적인 freestanding 헤더입니다. 스트림 반복자를 제외한 이 헤더 내의 모든 것은 freestanding입니다.

(since C++23)

목차

개념

Iterator 개념
(C++20)
타입이 * 연산자를 적용하여 간접적으로 읽을 수 있음을 명시
(concept)
(C++20)
반복자가 참조하는 객체에 값을 쓸 수 있음을 명시
(concept)
(C++20)
semiregular 타입이 전위 및 후위 증가 연산자로 증가될 수 있음을 명시
(concept)
(C++20)
weakly_incrementable 타입의 증가 연산이 등식 보존 을 하며, 해당 타입이 equality_comparable 임을 명시합니다.
(컨셉)
(C++20)
해당 타입의 객체가 증가 및 역참조될 수 있음을 명시
(concept)
(C++20)
특정 타입이 input_or_output_iterator 타입에 대한 센티넬(sentinel)임을 명시합니다
(컨셉)
(C++20)
반복자와 센티널에 - 연산자를 적용하여 상수 시간에 그 차이를 계산할 수 있음을 명시
(컨셉)
(C++20)
타입이 입력 반복자임을 명시합니다. 즉, 참조된 값을 읽을 수 있고 전위 및 후위 증가가 모두 가능함
(concept)
(C++20)
주어진 값 타입에 대해 타입이 출력 반복자임을 명시합니다. 즉, 해당 타입의 값을 쓸 수 있으며 사전 증가와 사후 증가가 모두 가능함
(concept)
(C++20)
input_iterator 가 순방향 반복자임을 지정하며, 동등 비교와 다중 패스를 지원함
(concept)
(C++20)
forward_iterator 가 양방향 반복자임을 지정하며, 뒤로 이동을 지원함
(concept)
(C++20)
bidirectional_iterator 가 상수 시간 내 전진 및 첨자 연산을 지원하는 임의 접근 반복자임을 명시
(concept)
(C++20)
메모리에서 연속적인 요소들을 참조하는 random_access_iterator 가 연속 반복자임을 지정합니다
(concept)
간접 호출 가능 개념
(C++20) (C++20)
호출 가능 타입이 indirectly_readable 타입을 역참조한 결과로 호출될 수 있음을 명시
(concept)
(C++20)
호출 가능 타입이 indirectly_readable 타입을 역참조한 결과로 호출될 때 predicate 를 만족함을 명시합니다.
(concept)
(C++20)
호출 가능 타입이 두 개의 indirectly_readable 타입을 역참조한 결과로 호출될 때 predicate 개념을 만족함을 명시합니다.
(concept)
(C++20)
호출 가능 타입이 두 개의 indirectly_readable 타입을 역참조한 결과로 호출될 때 equivalence_relation 을 만족함을 명시합니다.
(concept)
(C++20)
호출 가능 타입이 두 개의 indirectly_readable 타입을 역참조한 결과로 호출될 때 strict_weak_order 를 만족함을 명시합니다.
(concept)
공통 알고리즘 요구사항
(C++20)
indirectly_readable 타입에서 indirectly_writable 타입으로 값들이 이동될 수 있음을 명시합니다
(concept)
(C++20)
indirectly_readable 타입에서 indirectly_writable 타입으로 값들이 이동될 수 있으며, 해당 이동이 중간 객체를 통해 수행될 수 있음을 명시합니다
(concept)
(C++20)
indirectly_readable 타입에서 indirectly_writable 타입으로 값이 복사될 수 있음을 명시
(concept)
(C++20)
indirectly_readable 타입에서 indirectly_writable 타입으로 값들이 복사될 수 있으며, 복사가 중간 객체를 통해 수행될 수 있음을 명시함
(concept)
(C++20)
두 개의 indirectly_readable 타입이 참조하는 값들이 교환될 수 있음을 명시함
(concept)
(C++20)
두 indirectly_readable 타입으로 참조되는 값들이 비교 가능함을 명시
(concept)
(C++20)
제자리에서 요소들을 재배열하는 알고리즘들의 공통 요구사항을 명시함
(concept)
(C++20)
정렬된 시퀀스를 요소 복사를 통해 출력 시퀀스로 병합하는 알고리즘의 요구 사항을 명시함
(concept)
(C++20)
시퀀스를 정렬된 시퀀스로 재배열하는 알고리즘의 공통 요구 사항을 명시함
(concept)

클래스

알고리즘 유틸리티
(C++20)
일부 indirectly_readable 타입들을 역참조한 결과에 대해 호출 가능 객체를 호출한 결과를 계산함
(alias template)
(C++20)
투영(projection)을 수용하는 알고리즘의 제약 조건을 지정하기 위한 헬퍼 템플릿
(alias template)
(C++26)
투영을 통해 indirectly_readable 타입의 값 타입을 계산함
(alias template)
연관 타입
(C++20)
weakly_incrementable 타입의 차이 타입을 계산함
(클래스 템플릿)
(C++20)
indirectly_readable 타입의 값 타입을 계산함
(클래스 템플릿)
(C++20) (C++20) (C++23) (C++20) (C++20) (C++20)
반복자의 연관된 타입들을 계산함
(alias template)
기본형
반복자의 속성에 대한 통일된 인터페이스를 제공합니다
(클래스 템플릿)
(C++20)
반복자 카테고리를 나타내는 데 사용되는 빈 클래스 타입
(클래스)
(deprecated in C++17)
단순 반복자에 필요한 타입 정의를 용이하게 하는 기본 클래스
(class template)
어댑터
역순 순회를 위한 반복자 어댑터
(클래스 템플릿)
(C++11)
rvalue로 역참조하는 iterator adaptor
(class template)
(C++20)
std::move_iterator 를 위한 센티넬 어댑터
(클래스 템플릿)
(C++23)
반복자를 상수 반복자로 변환하는 반복자 어댑터
(클래스 템플릿)
(C++23)
주어진 타입에 대한 상수 반복자 타입을 계산합니다
(alias template)
(C++23)
상수 반복자와 함께 사용할 sentinel 타입을 계산합니다
(alias template)
(C++20)
반복자 타입과 센티넬을 공통 반복자 타입으로 적응시킵니다
(클래스 템플릿)
(C++20)
자신의 범위 경계를 알고 있는 반복자와 함께 사용하기 위한 기본 센티널
(클래스)
(C++20)
범위의 끝까지 거리를 추적하는 반복자 어댑터
(클래스 템플릿)
(C++20)
어떤 weakly_incrementable 타입과도 항상 같지 않음을 비교하는 sentinel
(클래스)
컨테이너의 끝에 삽입을 위한 반복자 어댑터
(클래스 템플릿)
컨테이너의 앞쪽에 삽입하기 위한 iterator 어댑터
(클래스 템플릿)
컨테이너에 삽입하기 위한 반복자 어댑터
(클래스 템플릿)
스트림 반복자
std::basic_istream 에서 읽어들이는 입력 반복자
(클래스 템플릿)
std::basic_ostream에 쓰기 작업을 수행하는 std::basic_ostream
(클래스 템플릿)
std::basic_streambuf에서 읽어들이는 std::basic_streambuf
(클래스 템플릿)
std::basic_streambuf 에 쓰기를 수행하는 출력 반복자
(클래스 템플릿)

커스터마이제이션 포인트 객체

네임스페이스 std::ranges 에 정의됨
(C++20)
객체를 역참조한 결과를 해당 rvalue 참조 타입으로 변환합니다
(커스터마이제이션 포인트 객체)
(C++20)
역참조 가능한 두 객체가 참조하는 값을 교환합니다
(커스터마이제이션 포인트 객체)

상수

(C++20)
unreachable_sentinel_t 타입의 객체로, 항상 모든 weakly_incrementable 타입과 비교 시 같지 않음
(상수)
(C++20)
자신의 범위 경계를 알고 있는 반복자와 함께 사용되는 default_sentinel_t 타입의 객체
(상수)

함수

Adaptors
(C++14)
인자의 타입으로부터 추론된 std::reverse_iterator 를 생성합니다
(함수 템플릿)
(C++11)
인수로부터 타입이 추론된 std::move_iterator 를 생성합니다
(함수 템플릿)
(C++23)
인수로부터 타입이 추론되는 std::const_iterator 를 생성함
(함수 템플릿)
(C++23)
인자의 타입으로부터 추론된 std::const_sentinel 을 생성합니다
(함수 템플릿)
인수로부터 추론된 타입의 std::front_insert_iterator 를 생성합니다
(함수 템플릿)
인수로부터 추론된 타입의 std::back_insert_iterator 를 생성합니다
(함수 템플릿)
인수로부터 추론된 타입의 std::insert_iterator 를 생성함
(함수 템플릿)
비멤버 연산자
(C++11) (C++11) (C++20에서 제거됨) (C++11) (C++11) (C++11) (C++11) (C++20)
기본 반복자를 비교함
(함수 템플릿)
(C++11)
반복자를 전진시킵니다
(함수 템플릿)
(C++11)
두 반복자 어댑터 간의 거리를 계산합니다
(함수 템플릿)
(C++20)
기본 반복자를 비교합니다
(함수 템플릿)
반복자를 전진시킵니다
(함수 템플릿)
두 반복자 어댑터 간의 거리를 계산합니다
(함수 템플릿)
(C++20)
끝까지의 거리를 비교합니다
(함수 템플릿)
(C++20)
반복자를 전진시킴
(함수 템플릿)
(C++20)
두 반복자 어댑터 간의 거리를 계산합니다
(함수 템플릿)
(C++20에서 제거됨)
두 istream_iterator 를 비교함
(함수 템플릿)
(C++20에서 제거됨)
두 istreambuf_iterator 를 비교함
(함수 템플릿)
연산
주어진 거리만큼 반복자를 전진시킵니다
(함수 템플릿)
두 반복자 사이의 거리를 반환합니다
(함수 템플릿)
(C++11)
반복자를 증가시킴
(함수 템플릿)
(C++11)
반복자를 감소시킴
(함수 템플릿)
(C++20)
주어진 거리만큼 또는 주어진 경계까지 반복자를 전진시킴
(알고리즘 함수 객체)
(C++20)
반복자와 센티넬 사이의 거리 또는 범위의 시작과 끝 사이의 거리를 반환합니다
(알고리즘 함수 객체)
(C++20)
주어진 거리만큼 또는 경계까지 반복자를 증가시킴
(알고리즘 함수 객체)
(C++20)
주어진 거리만큼 또는 경계까지 반복자를 감소시킴
(알고리즘 함수 객체)
범위 접근
(C++11) (C++14)
컨테이너나 배열의 시작 부분에 대한 반복자를 반환합니다
(함수 템플릿)
(C++11) (C++14)
컨테이너나 배열의 끝을 가리키는 반복자를 반환합니다
(함수 템플릿)
(C++14)
컨테이너나 배열의 시작 부분에 대한 역방향 반복자를 반환합니다
(함수 템플릿)
(C++14)
컨테이너나 배열에 대한 역방향 끝 반복자를 반환합니다
(함수 템플릿)
(C++17) (C++20)
컨테이너나 배열의 크기를 반환합니다
(함수 템플릿)
(C++17)
컨테이너가 비어 있는지 확인합니다
(함수 템플릿)
(C++17)
기본 배열에 대한 포인터를 획득합니다
(함수 템플릿)

시놉시스 

#include <compare>
#include <concepts>
namespace std {
  template<class T> using /* with-reference */ = T&;  // 설명 전용
  template<class T> concept /* 참조-가능 */       // 설명 전용
    = requires { typename /* with-reference */<T>; };
  template<class T> concept /* 역참조 가능 */     // 설명 전용
    = requires(T& t) {
      { *t } -> /* 참조-가능 */;  // 동등성 보존이 필요하지 않음
    };
  // 연관 타입
  // incrementable traits
  template<class> struct incrementable_traits;
  template<class T>
    using iter_difference_t = /* 설명 참조 */;
  // 간접적으로 읽을 수 있는 특성
  template<class> struct indirectly_readable_traits;
  template<class T>
    using iter_value_t = /* 설명 참조 */;
  // iterator traits
  template<class I> struct iterator_traits;
  template<class T> requires is_object_v<T> struct iterator_traits<T*>;
  template</* 역참조 가능 */ T>
    using iter_reference_t = decltype(*declval<T&>());
  namespace ranges {
    // customization point objects
    inline namespace /* 미지정 */ {
      // ranges::iter_move
      inline constexpr /* 미지정 */ iter_move = /* 미지정 */;
      // ranges::iter_swap
      inline constexpr /* 미지정 */ iter_swap = /* 미지정 */;
    }
  }
  template</* 역참조 가능 */ T>
    requires requires(T& t) {
      { ranges::iter_move(t) } -> /* 참조-가능 */;
    }
  using iter_rvalue_reference_t
    = decltype(ranges::iter_move(declval<T&>()));
  // iterator concepts
  // concept indirectly_readable
  template<class In>
    concept indirectly_readable = /* 설명 참조 */;
  template<indirectly_readable T>
    using iter_common_reference_t =
      common_reference_t<iter_reference_t<T>, iter_value_t<T>&>;
  // concept indirectly_writable
  template<class Out, class T>
    concept indirectly_writable = /* 설명 참조 */;
  // concept weakly_incrementable
  template<class I>
    concept weakly_incrementable = /* 설명 참조 */;
  // 개념 incrementable
  template<class I>
    concept incrementable = /* 설명 참조 */;
  // concept input_or_output_iterator
  template<class I>
    concept input_or_output_iterator = /* 설명 참조 */;
  // concept sentinel_for
  template<class S, class I>
    concept sentinel_for = /* 설명 참조 */;
  // concept sized_sentinel_for
  template<class S, class I>
    inline constexpr bool disable_sized_sentinel_for = false;
  template<class S, class I>
    concept sized_sentinel_for = /* 설명 참조 */;
  // concept input_iterator
  template<class I>
    concept input_iterator = /* 설명 참조 */;
  // concept output_iterator
  template<class I, class T>
    concept output_iterator = /* 설명 참조 */;
  // concept forward_iterator
  template<class I>
    concept forward_iterator = /* 설명 참조 */;
  // concept bidirectional_iterator
  template<class I>
    concept bidirectional_iterator = /* 설명 참조 */;
  // concept random_access_iterator
  template<class I>
    concept random_access_iterator = /* 설명 참조 */;
  // concept contiguous_iterator
  template<class I>
    concept contiguous_iterator = /* 설명 참조 */;
  // 간접 호출 가능 요구사항
  // 간접 호출 가능 객체
  template<class F, class I>
    concept indirectly_unary_invocable = /* 설명 참조 */;
  template<class F, class I>
    concept indirectly_regular_unary_invocable = /* 설명 참조 */;
  template<class F, class I>
    concept indirect_unary_predicate = /* 설명 참조 */;
  template<class F, class I1, class I2>
    concept indirect_binary_predicate = /* 설명 참조 */;
  template<class F, class I1, class I2 = I1>
    concept indirect_equivalence_relation = /* 설명 참조 */;
  template<class F, class I1, class I2 = I1>
    concept indirect_strict_weak_order = /* 설명 참조 */;
  template<class F, class... Is>
    requires (indirectly_readable<Is> && ...) && invocable<F, iter_reference_t<Is>...>
      using indirect_result_t = invoke_result_t<F, iter_reference_t<Is>...>;
  // projected
  template<indirectly_readable I, indirectly_regular_unary_invocable<I> Proj>
    using projected = /* 설명 참조 */;
  template<indirectly_­readable I, indirectly_­regular_­unary_­invocable<I> Proj>
    using projected_value_t = remove_cvref_t<invoke_result_t<Proj&, iter_value_t<I>&>>;
  // 공통 알고리즘 요구사항
  // concept indirectly_movable
  template<class In, class Out>
    concept indirectly_movable = /* 설명 참조 */;
  template<class In, class Out>
    concept indirectly_movable_storable = /* 설명 참조 */;
  // concept indirectly_copyable
  template<class In, class Out>
    concept indirectly_copyable = /* 설명 참조 */;
  template<class In, class Out>
    concept indirectly_copyable_storable = /* 설명 참조 */;
  // concept indirectly_swappable
  template<class I1, class I2 = I1>
    concept indirectly_swappable = /* 설명 참조 */;
  // concept indirectly_comparable
  template<class I1, class I2, class R, class P1 = identity, class P2 = identity>
    concept indirectly_comparable = /* 설명 참조 */;
  // concept permutable
  template<class I>
    concept permutable = /* 설명 참조 */;
  // concept mergeable
  template<class I1, class I2, class Out,
      class R = ranges::less, class P1 = identity, class P2 = identity>
    concept mergeable = /* 설명 참조 */;
  // concept sortable
  template<class I, class R = ranges::less, class P = identity>
    concept sortable = /* 설명 참조 */;
  // primitives
  // iterator tags
  struct input_iterator_tag { };
  struct output_iterator_tag { };
  struct forward_iterator_tag: public input_iterator_tag { };
  struct bidirectional_iterator_tag: public forward_iterator_tag { };
  struct random_access_iterator_tag: public bidirectional_iterator_tag { };
  struct contiguous_iterator_tag: public random_access_iterator_tag { };
  // iterator operations
  template<class InputIt, class Distance>
    constexpr void advance(InputIt& i, Distance n);
  template<class InputIt>
    constexpr typename iterator_traits<InputIt>::difference_type
      distance(InputIt first, InputIt last);
  template<class InputIt>
    constexpr InputIt
      next(InputIt x, typename iterator_traits<InputIt>::difference_type n = 1);
  template<class BidirIt>
    constexpr BidirIt
      prev(BidirIt x, typename iterator_traits<BidirIt>::difference_type n = 1);
  // range iterator operations
  namespace ranges {
    // ranges::advance
    template<input_or_output_iterator I>
      constexpr void advance(I& i, iter_difference_t<I> n);
    template<input_or_output_iterator I, sentinel_for<I> S>
      constexpr void advance(I& i, S bound);
    template<input_or_output_iterator I, sentinel_for<I> S>
      constexpr iter_difference_t<I> advance(I& i, iter_difference_t<I> n, S bound);
    // ranges::distance
    template<class I, sentinel_for<I> S>
      requires (!sized_sentinel_for<S, I>)
      constexpr iter_difference_t<I> distance(I first, S last);
    template<class I, sized_sentinel_for<decay_t<I>> S>
      constexpr iter_difference_t<decay_t<I>> distance(I&& first, S last);
    template<range R>
      constexpr range_difference_t<R> distance(R&& r);
    // ranges::next
    template<input_or_output_iterator I>
      constexpr I next(I x);
    template<input_or_output_iterator I>
      constexpr I next(I x, iter_difference_t<I> n);
    template<input_or_output_iterator I, sentinel_for<I> S>
      constexpr I next(I x, S bound);
    template<input_or_output_iterator I, sentinel_for<I> S>
      constexpr I next(I x, iter_difference_t<I> n, S bound);
    // ranges::prev
    template<bidirectional_iterator I>
      constexpr I prev(I x);
    template<bidirectional_iterator I>
      constexpr I prev(I x, iter_difference_t<I> n);
    template<bidirectional_iterator I>
      constexpr I prev(I x, iter_difference_t<I> n, I bound);
  }
  // 미리 정의된 반복자와 센티널
  // reverse iterators
  template<class It> class reverse_iterator;
  template<class It1, class It2>
    constexpr bool operator==(const reverse_iterator<It1>& x,
                              const reverse_iterator<It2>& y);
  template<class It1, class It2>
    constexpr bool operator!=(const reverse_iterator<It1>& x,
                              const reverse_iterator<It2>& y);
  template<class It1, class It2>
    constexpr bool operator<(const reverse_iterator<It1>& x,
                             const reverse_iterator<It2>& y);
  template<class It1, class It2>
    constexpr bool operator>(const reverse_iterator<It1>& x,
                             const reverse_iterator<It2>& y);
  template<class It1, class It2>
    constexpr bool operator<=(const reverse_iterator<It1>& x,
                              const reverse_iterator<It2>& y);
  template<class It1, class It2>
    constexpr bool operator>=(const reverse_iterator<It1>& x,
                              const reverse_iterator<It2>& y);
  template<class It1, three_way_comparable_with<It1> It2>
    constexpr compare_three_way_result_t<It1, It2>
      operator<=>(const reverse_iterator<It1>& x, const reverse_iterator<It2>& y);
  template<class It1, class It2>
    constexpr auto operator-(const reverse_iterator<It1>& x,
                             const reverse_iterator<It2>& y)
      -> decltype(y.base() - x.base());
  template<class It>
    constexpr reverse_iterator<It> operator+(iter_difference_t<It> n,
                                             const reverse_iterator<It>& x);
  template<class It>
    constexpr reverse_iterator<It> make_reverse_iterator(It i);
  template<class It1, class It2>
      requires (!sized_sentinel_for<It1, It2>)
    inline constexpr bool disable_sized_sentinel_for<reverse_iterator<It1>,
                                                     reverse_iterator<It2>> = true;
  // insert iterators
  template<class Container> class back_insert_iterator;
  template<class Container>
    constexpr back_insert_iterator<Container> back_inserter(Container& x);
  template<class Container> class front_insert_iterator;
  template<class Container>
    constexpr front_insert_iterator<Container> front_inserter(Container& x);
  template<class Container> class insert_iterator;
  template<class Container>
    constexpr insert_iterator<Container>
      inserter(Container& x, ranges::iterator_t<Container> i);
  // move iterators and sentinels
  template<class It> class move_iterator;
  template<class It1, class It2>
    constexpr bool operator==(const move_iterator<It1>& x, const move_iterator<It2>& y);
  template<class It1, class It2>
    constexpr bool operator<(const move_iterator<It1>& x, const move_iterator<It2>& y);
  template<class It1, class It2>
    constexpr bool operator>(const move_iterator<It1>& x, const move_iterator<It2>& y);
  template<class It1, class It2>
    constexpr bool operator<=(const move_iterator<It1>& x, const move_iterator<It2>& y);
  template<class It1, class It2>
    constexpr bool operator>=(const move_iterator<It1>& x, const move_iterator<It2>& y);
  template<class It1, three_way_comparable_with<It1> It2>
    constexpr compare_three_way_result_t<It1, It2>
      operator<=>(const move_iterator<It1>& x, const move_iterator<It2>& y);
  template<class It1, class It2>
    constexpr auto operator-(const move_iterator<It1>& x, const move_iterator<It2>& y)
      -> decltype(x.base() - y.base());
  template<class It>
    constexpr move_iterator<It>
      operator+(iter_difference_t<It> n, const move_iterator<It>& x);
  template<class It>
    constexpr move_iterator<It> make_move_iterator(It i);
  template<semiregular S> class move_sentinel;
  // 공통 반복자
  template<input_or_output_iterator I, sentinel_for<I> S>
    requires (!same_as<I, S> && copyable<I>)
      class common_iterator;
  template<class I, class S>
    struct incrementable_traits<common_iterator<I, S>>;
  template<input_iterator I, class S>
    struct iterator_traits<common_iterator<I, S>>;
  // 기본 센티널
  struct default_sentinel_t;
  inline constexpr default_sentinel_t default_sentinel{};
  // counted iterators
  template<input_or_output_iterator I> class counted_iterator;
  template<input_iterator I>
    requires /* 설명 참조 */
    struct iterator_traits<counted_iterator<I>>;
  // 도달할 수 없는 센티널
  struct unreachable_sentinel_t;
  inline constexpr unreachable_sentinel_t unreachable_sentinel{};
  // 스트림 반복자
  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 = 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 = char_traits<CharT>>
    class ostreambuf_iterator;
  // 범위 접근
  template<class C> constexpr auto begin(C& c) -> decltype(c.begin());
  template<class C> constexpr auto begin(const C& c) -> decltype(c.begin());
  template<class C> constexpr auto end(C& c) -> decltype(c.end());
  template<class C> constexpr auto end(const C& c) -> decltype(c.end());
  template<class T, size_t N> constexpr T* begin(T (&a)[N]) noexcept;
  template<class T, size_t N> constexpr T* end(T (&a)[N]) noexcept;
  template<class C> constexpr auto cbegin(const C& c) noexcept(noexcept(std::begin(c)))
    -> decltype(std::begin(c));
  template<class C> constexpr auto cend(const C& c) noexcept(noexcept(std::end(c)))
    -> decltype(std::end(c));
  template<class C> constexpr auto rbegin(C& c) -> decltype(c.rbegin());
  template<class C> constexpr auto rbegin(const C& c) -> decltype(c.rbegin());
  template<class C> constexpr auto rend(C& c) -> decltype(c.rend());
  template<class C> constexpr auto rend(const C& c) -> decltype(c.rend());
  template<class T, size_t N> constexpr reverse_iterator<T*> rbegin(T (&a)[N]);
  template<class T, size_t N> constexpr reverse_iterator<T*> rend(T (&a)[N]);
  template<class E> constexpr reverse_iterator<const E*> rbegin(initializer_list<E> il);
  template<class E> constexpr reverse_iterator<const E*> rend(initializer_list<E> il);
  template<class C> constexpr auto crbegin(const C& c) -> decltype(std::rbegin(c));
  template<class C> constexpr auto crend(const C& c) -> decltype(std::rend(c));
  template<class C> constexpr auto size(const C& c) -> decltype(c.size());
  template<class T, size_t N> constexpr size_t size(const T (&a)[N]) noexcept;
  template<class C> constexpr auto ssize(const C& c)
    -> common_type_t<ptrdiff_t, make_signed_t<decltype(c.size())>>;
  template<class T, ptrdiff_t N> constexpr ptrdiff_t ssize(const T (&a)[N]) noexcept;
  template<class C> constexpr auto empty(const C& c) -> decltype(c.empty());
  template<class T, size_t N> constexpr bool empty(const T (&a)[N]) noexcept;
  template<class E> constexpr bool empty(initializer_list<E> il) noexcept;
  template<class C> constexpr auto data(C& c) -> decltype(c.data());
  template<class C> constexpr auto data(const C& c) -> decltype(c.data());
  template<class T, size_t N> constexpr T* data(T (&a)[N]) noexcept;
  template<class E> constexpr const E* data(initializer_list<E> il) noexcept;
}

컨셉 indirectly_readable 

namespace std {
  template<class In>
    concept /*indirectlyReadableImpl*/ = // 설명 전용
      requires(const In in) {
        typename iter_value_t<In>;
        typename iter_reference_t<In>;
        typename iter_rvalue_reference_t<In>;
        { *in } -> same_as<iter_reference_t<In>>
        { iter_move(in) } -> same_as<iter_rvalue_reference_t<In>>
      } &&
      common_reference_with<iter_reference_t<In>&&, iter_value_t<In>&> &&
      common_reference_with<iter_reference_t<In>&&, iter_rvalue_reference_t<In>&&> &&
      common_reference_with<iter_rvalue_reference_t<In>&&, const iter_value_t<In>&>;
  template<class In>
    concept indirectly_readable =
      /*indirectlyReadableImpl*/<remove_cvref_t<In>>
}

개념 indirectly_writable 

namespace std {
  template<class Out, class T>
    concept indirectly_writable =
      requires(Out&& o, T&& t) {
        *o = std::forward<T>(t); // 동등성 보존이 요구되지 않음
        *std::forward<Out>(o) = std::forward<T>(t);
        // 동등성 보존이 요구되지 않음
        const_cast<const iter_reference_t<Out>&&>(*o) =
        std::forward<T>(t); // 동등성 보존이 요구되지 않음
        const_cast<const iter_reference_t<Out>&&>(*std::forward<Out>(o)) =
        std::forward<T>(t); // 동등성 보존이 요구되지 않음
      };
}

개념 weakly_incrementable 

namespace std {
  template<class T>
    inline constexpr bool /*is_integer_like*/ = /* 설명 참조 */; // 설명 전용
  template<class T>
    inline constexpr bool /*is_signed_integer_like*/ =  // 설명 전용
      /* 설명 참조 */;
  template<class I>
    concept weakly_incrementable =
      default_initializable<I> && movable<I> &&
      requires(I i) {
        typename iter_difference_t<I>;
        requires /*is_signed_integer_like*/<iter_difference_t<I>>;
        { ++i } -> same_as<I&>;   // 동등성 보존이 요구되지 않음
        i++;                      // 동등성 보존이 요구되지 않음
      };
}

개념 incrementable 

namespace std {
  template<class I>
    concept incrementable =
      regular<I> &&
      weakly_incrementable<I> &&
      requires(I i) {
        { i++ } -> same_as<I>;
      };
}

개념 input_or_output_iterator 

namespace std {
  template<class I>
    concept input_or_output_iterator =
      requires(I i) {
        { *i } -> can-reference;
      } &&
      weakly_incrementable<I>;
}

컨셉 sentinel_for 

namespace std {
  template<class S, class I>
    concept sentinel_for =
      semiregular<S> &&
      input_or_output_iterator<I> &&
      /*WeaklyEqualityComparableWith*/<S, I>;
}

컨셉 sized_sentinel_for 

namespace std {
  template<class S, class I>
    concept sized_sentinel_for =
      sentinel_for<S, I> &&
      !disable_sized_sentinel<remove_cv_t<S>, remove_cv_t<I>> &&
      requires(const I& i, const S& s) {
        { s - i } -> same_as<iter_difference_t<I>>;
        { i - s } -> same_as<iter_difference_t<I>>;
      };
}

개념 input_iterator 

namespace std {
  template<class I>
    concept input_iterator =
      input_or_output_iterator<I> &&
      indirectly_readable<I> &&
      requires { typename /* ITER_CONCEPT */(I); } &&
      derived_from</* ITER_CONCEPT */(I), input_iterator_tag>;
}

개념 output_iterator 

namespace std {
  template<class I, class T>
    concept output_iterator =
      input_or_output_iterator<I> &&
      indirectly_writable<I, T> &&
      requires(I i, T&& t) {
        *i++ = std::forward<T>(t); // 동등성 보존이 요구되지 않음
      };
}

개념 forward_iterator 

namespace std {
  template<class I>
    concept forward_iterator =
      input_iterator<I> &&
      derived_from</* ITER_CONCEPT */(I), forward_iterator_tag> &&
      incrementable<I> &&
      sentinel_for<I, I>;
}

개념 bidirectional_iterator 

namespace std {
  template<class I>
    concept bidirectional_iterator =
      forward_iterator<I> &&
      derived_from</* ITER_CONCEPT */(I), bidirectional_iterator_tag> &&
      requires(I i) {
        { --i } -> same_as<I&>;
        { i-- } -> same_as<I>;
      };
}

개념 random_access_iterator 

namespace std {
  template<class I>
    concept random_access_iterator =
      bidirectional_iterator<I> &&
      derived_from</* ITER_CONCEPT */(I), random_access_iterator_tag> &&
      totally_ordered<I> &&
      sized_sentinel_for<I, I> &&
      requires(I i, const I j, const iter_difference_t<I> n) {
        { i += n } -> same_as<I&>;
        { j +  n } -> same_as<I>;
        { n +  j } -> same_as<I>;
        { i -= n } -> same_as<I&>;
        { j -  n } -> same_as<I>;
        {  j[n]  } -> same_as<iter_reference_t<I>>;
      };
}

컨셉 contiguous_iterator 

namespace std {
  template<class I>
    concept contiguous_iterator =
      random_access_iterator<I> &&
      derived_from</* ITER_CONCEPT */(I), contiguous_iterator_tag> &&
      is_lvalue_reference_v<iter_reference_t<I>> &&
      same_as<iter_value_t<I>, remove_cvref_t<iter_reference_t<I>>> &&
      requires(const I& i) {
        { to_address(i) } -> same_as<add_pointer_t<iter_reference_t<I>>>;
      };
}

개념 indirectly_unary_invocable 

namespace std {
  template<class F, class I>
    concept indirectly_unary_invocable =
      indirectly_readable<I> &&
      copy_constructible<F> &&
      invocable<F&, iter_value_t<I>&> &&
      invocable<F&, iter_reference_t<I>> &&
      common_reference_with<
        invoke_result_t<F&, iter_value_t<I>&>,
        invoke_result_t<F&, iter_reference_t<I>>>;
}

개념 indirectly_regular_unary_invocable 

namespace std {
  template<class F, class I>
    concept indirectly_regular_unary_invocable =
      indirectly_readable<I> &&
      copy_constructible<F> &&
      regular_invocable<F&, iter_value_t<I>&> &&
      regular_invocable<F&, iter_reference_t<I>> &&
      common_reference_with<
        invoke_result_t<F&, iter_value_t<I>&>,
        invoke_result_t<F&, iter_reference_t<I>>>;
}

개념 indirect_unary_predicate 

namespace std {
  template<class F, class I>
    concept indirect_unary_predicate =
      indirectly_readable<I> &&
      copy_constructible<F> &&
      predicate<F&, iter_value_t<I>&> &&
      predicate<F&, iter_reference_t<I>>;
}

개념 indirect_binary_predicate 

namespace std {
  template<class F, class I1, class I2 = I1>
    concept indirect_binary_predicate =
      indirectly_readable<I1> && indirectly_readable<I2> &&
      copy_constructible<F> &&
      predicate<F&, iter_value_t<I1>&, iter_value_t<I2>&> &&
      predicate<F&, iter_value_t<I1>&, iter_reference_t<I2>> &&
      predicate<F&, iter_reference_t<I1>, iter_value_t<I2>&> &&
      predicate<F&, iter_reference_t<I1>, iter_reference_t<I2>>;
}

개념 indirect_equivalence_relation 

namespace std {
  template<class F, class I1, class I2 = I1>
    concept indirect_equivalence_relation =
      indirectly_readable<I1> && indirectly_readable<I2> &&
      copy_constructible<F> &&
      equivalence_relation<F&, iter_value_t<I1>&, iter_value_t<I2>&> &&
      equivalence_relation<F&, iter_value_t<I1>&, iter_reference_t<I2>> &&
      equivalence_relation<F&, iter_reference_t<I1>, iter_value_t<I2>&> &&
      equivalence_relation<F&, iter_reference_t<I1>, iter_reference_t<I2>>;
}

개념 indirect_strict_weak_order 

namespace std {
  template<class F, class I1, class I2 = I1>
    concept indirect_strict_weak_order =
      indirectly_readable<I1> && indirectly_readable<I2> &&
      copy_constructible<F> &&
      strict_weak_order<F&, iter_value_t<I1>&, iter_value_t<I2>&> &&
      strict_weak_order<F&, iter_value_t<I1>&, iter_reference_t<I2>> &&
      strict_weak_order<F&, iter_reference_t<I1>, iter_value_t<I2>&> &&
      strict_weak_order<F&, iter_reference_t<I1>, iter_reference_t<I2>>;
}

개념 indirectly_movable 

namespace std {
  template<class In, class Out>
    concept indirectly_movable =
      indirectly_readable<In> &&
      indirectly_writable<Out, iter_rvalue_reference_t<In>>;
}

개념 indirectly_movable_storable 

namespace std {
  template<class In, class Out>
    concept indirectly_movable_storable =
      indirectly_movable<In, Out> &&
      indirectly_writable<Out, iter_value_t<In>> &&
      movable<iter_value_t<In>> &&
      constructible_from<iter_value_t<In>, iter_rvalue_reference_t<In>> &&
      assignable_from<iter_value_t<In>&, iter_rvalue_reference_t<In>>;
}

개념 indirectly_copyable 

namespace std {
  template<class In, class Out>
    concept indirectly_copyable =
      indirectly_readable<In> &&
      indirectly_writable<Out, iter_reference_t<In>>;
}

개념 indirectly_copyable_storable 

namespace std {
  template<class In, class Out>
    concept indirectly_copyable_storable =
      indirectly_copyable<In, Out> &&
      indirectly_writable<Out, iter_value_t<In>&> &&
      indirectly_writable<Out, const iter_value_t<In>&> &&
      indirectly_writable<Out, iter_value_t<In>&&> &&
      indirectly_writable<Out, const iter_value_t<In>&&> &&
      copyable<iter_value_t<In>> &&
      constructible_from<iter_value_t<In>, iter_reference_t<In>> &&
      assignable_from<iter_value_t<In>&, iter_reference_t<In>>;
}

개념 indirectly_swappable 

namespace std {
  template<class I1, class I2 = I1>
    concept indirectly_swappable =
      indirectly_readable<I1> && indirectly_readable<I2> &&
      requires(const I1 i1, const I2 i2) {
        ranges::iter_swap(i1, i1);
        ranges::iter_swap(i2, i2);
        ranges::iter_swap(i1, i2);
        ranges::iter_swap(i2, i1);
      };
}

컨셉 indirectly_comparable 

namespace std {
  template<class I1, class I2, class R, class P1 = identity, class P2 = identity>
    concept indirectly_comparable =
      indirect_predicate<R, projected<I1, P1>, projected<I2, P2>>;
}

개념 permutable 

namespace std {
  template<class I>
    concept permutable =
      forward_iterator<I> &&
      indirectly_movable_storable<I, I> &&
      indirectly_swappable<I, I>;
}

개념 mergeable 

namespace std {
  template<class I1, class I2, class Out, class R = ranges::less,
           class P1 = identity, class P2 = identity>
    concept mergeable =
      input_iterator<I1> &&
      input_iterator<I2> &&
      weakly_incrementable<Out> &&
      indirectly_copyable<I1, Out> &&
      indirectly_copyable<I2, Out> &&
      indirect_strict_weak_order<R, projected<I1, P1>, projected<I2, P2>>;
}

컨셉 sortable 

namespace std {
  template<class I, class R = ranges::less, class P = identity>
    concept sortable =
      permutable<I> &&
      indirect_strict_weak_order<R, projected<I, P>>;
}

클래스 템플릿 std::incrementable_traits 

namespace std {
  template<class> struct incrementable_traits { };
  template<class T>
    requires is_object_v<T>
  struct incrementable_traits<T*> {
    using difference_type = ptrdiff_t;
  };
  template<class I>
  struct incrementable_traits<const I>
    : incrementable_traits<I> { };
  template<class T>
    requires requires { typename T::difference_type; }
  struct incrementable_traits<T> {
    using difference_type = typename T::difference_type;
  };
  template<class T>
    requires (!requires { typename T::difference_type; } &&
              requires(const T& a, const T& b) { { a - b } -> integral; })
  struct incrementable_traits<T> {
    using difference_type = make_signed_t<decltype(declval<T>() - declval<T>())>;
  };
  template<class T>
    using iter_difference_t = /* 설명 참조 */;
}

클래스 템플릿 std::indirectly_readable_traits 

namespace std {
  template<class> struct /*cond_value_type*/ { };   // 설명 전용
  template<class T>
    requires is_object_v<T>
  struct /*cond_value_type*/ {
    using value_type = remove_cv_t<T>;
  };
  template<class> struct indirectly_readable_traits { };
  template<class T>
  struct indirectly_readable_traits<T*>
    : /*cond_value_type*/<T> { };
  template<class I>
    requires is_array_v<I>
  struct indirectly_readable_traits<I> {
    using value_type = remove_cv_t<remove_extent_t<I>>;
  };
  template<class I>
  struct indirectly_readable_traits<const I>
    : indirectly_readable_traits<I> { };
  template<class T>
    requires requires { typename T::value_type; }
  struct indirectly_readable_traits<T>
    : /*cond_value_type*/<typename T::value_type> { };
  template<class T>
    requires requires { typename T::element_type; }
  struct indirectly_readable_traits<T>
    : /*cond_value_type*/<typename T::element_type> { };
}

클래스 템플릿 std::projected 

namespace std {
  template<class I, class Proj>
  struct /*projected-impl*/ {                        // 설명용 전용
    struct /*type*/ {                                // 설명용 전용
      using value_type = remove_cvref_t<indirect_result_t<Proj&, I>>;
      using difference_type = iter_difference_t<I>;  // I가 weakly_incrementable을
                                                     // 모델링할 때만 존재
      indirect_result_t<Proj&, I> operator*() const; // 정의되지 않음
    };
  };
  template<indirectly_readable I, indirectly_regular_unary_invocable<I> Proj>
  using projected = /*projected-impl*/<I, Proj>::/*type*/;
}

클래스 템플릿 std::iterator_traits 

namespace std {
  template<class I>
  struct iterator_traits {
    using iterator_category = /* 설명 참조 */;
    using value_type        = /* 설명 참조 */;
    using difference_type   = /* 설명 참조 */;
    using pointer           = /* 설명 참조 */;
    using reference         = /* 설명 참조 */;
  };
  template<class T>
    requires is_object_v<T>
  struct iterator_traits<T*> {
    using iterator_concept  = contiguous_iterator_tag;
    using iterator_category = random_access_iterator_tag;
    using value_type        = remove_cv_t<T>;
    using difference_type   = ptrdiff_t;
    using pointer           = T*;
    using reference         = T&;
  };
}

반복자 태그 

namespace std {
  struct input_iterator_tag { };
  struct output_iterator_tag { };
  struct forward_iterator_tag: public input_iterator_tag { };
  struct bidirectional_iterator_tag: public forward_iterator_tag { };
  struct random_access_iterator_tag: public bidirectional_iterator_tag { };
  struct contiguous_iterator_tag: public random_access_iterator_tag { };
}

클래스 템플릿 std::reverse_iterator 

namespace std {
  template<class Iter>
  class reverse_iterator {
  public:
    using iterator_type     = Iter;
    using iterator_concept  = /* 설명 참조 */;
    using iterator_category = /* 설명 참조 */;
    using value_type        = iter_value_t<Iter>;
    using difference_type   = iter_difference_t<Iter>;
    using pointer           = typename iterator_traits<Iter>::pointer;
    using reference         = iter_reference_t<Iter>;
    constexpr reverse_iterator();
    constexpr explicit reverse_iterator(Iter x);
    template<class U> constexpr reverse_iterator(const reverse_iterator<U>& u);
    template<class U> constexpr reverse_iterator& operator=(const reverse_iterator<U>& u);
    constexpr Iter base() const;
    constexpr reference operator*() const;
    constexpr pointer   operator->() const requires /* 설명 참조 */;
    constexpr reverse_iterator& operator++();
    constexpr reverse_iterator  operator++(int);
    constexpr reverse_iterator& operator--();
    constexpr reverse_iterator  operator--(int);
    constexpr reverse_iterator  operator+ (difference_type n) const;
    constexpr reverse_iterator& operator+=(difference_type n);
    constexpr reverse_iterator  operator- (difference_type n) const;
    constexpr reverse_iterator& operator-=(difference_type n);
    constexpr /* 지정되지 않음 */ operator[](difference_type n) const;
    friend constexpr iter_rvalue_reference_t<Iter>
      iter_move(const reverse_iterator& i) noexcept(/* 설명 참조 */);
    template<indirectly_swappable<Iter> Iter2>
      friend constexpr void
        iter_swap(const reverse_iterator& x,
                  const reverse_iterator<Iter2>& y) noexcept(/* 설명 참조 */);
  protected:
    Iter current;
  };
}

클래스 템플릿 std::back_insert_iterator 

namespace std {
  template<class Container>
  class back_insert_iterator {
  protected:
    Container* container = nullptr;
  public:
    using iterator_category = output_iterator_tag;
    using value_type        = void;
    using difference_type   = ptrdiff_t;
    using pointer           = void;
    using reference         = void;
    using container_type    = Container;
    constexpr back_insert_iterator() noexcept = default;
    constexpr explicit back_insert_iterator(Container& x);
    constexpr back_insert_iterator& operator=(const typename Container::value_type& value);
    constexpr back_insert_iterator& operator=(typename Container::value_type&& value);
    constexpr back_insert_iterator& operator*();
    constexpr back_insert_iterator& operator++();
    constexpr back_insert_iterator  operator++(int);
  };
}

클래스 템플릿 std::front_insert_iterator 

namespace std {
  template<class Container>
  class front_insert_iterator {
  protected:
    Container* container = nullptr;
  public:
    using iterator_category = output_iterator_tag;
    using value_type        = void;
    using difference_type   = ptrdiff_t;
    using pointer           = void;
    using reference         = void;
    using container_type    = Container;
    constexpr front_insert_iterator(Container& x) noexcept = default;
    constexpr explicit front_insert_iterator(Container& x);
    constexpr front_insert_iterator&
      operator=(const typename Container::value_type& value);
    constexpr front_insert_iterator& operator=(typename Container::value_type&& value);
    constexpr front_insert_iterator& operator*();
    constexpr front_insert_iterator& operator++();
    constexpr front_insert_iterator  operator++(int);
  };
}

클래스 템플릿 std::insert_iterator 

namespace std {
  template<class Container>
  class insert_iterator {
  protected:
    Container* container = nullptr;
    ranges::iterator_t<Container> iter = ranges::iterator_t<Container>();
  public:
    using iterator_category = output_iterator_tag;
    using value_type        = void;
    using difference_type   = ptrdiff_t;
    using pointer           = void;
    using reference         = void;
    using container_type    = Container;
    insert_iterator() = default;
    constexpr insert_iterator(Container& x, ranges::iterator_t<Container> i);
    constexpr insert_iterator& operator=(const typename Container::value_type& value);
    constexpr insert_iterator& operator=(typename Container::value_type&& value);
    constexpr insert_iterator& operator*();
    constexpr insert_iterator& operator++();
    constexpr insert_iterator& operator++(int);
  };
}

클래스 템플릿 std::move_iterator 

namespace std {
  template<class Iter>
  class move_iterator {
  public:
    using iterator_type     = Iter;
    using iterator_concept  = /* 설명 참조 */;
    using iterator_category = /* 설명 참조 */;
    using value_type        = iter_value_t<Iter>;
    using difference_type   = iter_difference_t<Iter>;
    using pointer           = Iter;
    using reference         = iter_rvalue_reference_t<Iter>;
    constexpr move_iterator();
    constexpr explicit move_iterator(Iter i);
    template<class U> constexpr move_iterator(const move_iterator<U>& u);
    template<class U> constexpr move_iterator& operator=(const move_iterator<U>& u);
    constexpr iterator_type base() const &;
    constexpr iterator_type base() &&;
    constexpr reference operator*() const;
    constexpr pointer operator->() const;
    constexpr move_iterator& operator++();
    constexpr auto operator++(int);
    constexpr move_iterator& operator--();
    constexpr move_iterator operator--(int);
    constexpr move_iterator operator+(difference_type n) const;
    constexpr move_iterator& operator+=(difference_type n);
    constexpr move_iterator operator-(difference_type n) const;
    constexpr move_iterator& operator-=(difference_type n);
    constexpr reference operator[](difference_type n) const;
    template<sentinel_for<Iter> S>
      friend constexpr bool
        operator==(const move_iterator& x, const move_sentinel<S>& y);
    template<sized_sentinel_for<Iter> S>
      friend constexpr iter_difference_t<Iter>
        operator-(const move_sentinel<S>& x, const move_iterator& y);
    template<sized_sentinel_for<Iter> S>
      friend constexpr iter_difference_t<Iter>
        operator-(const move_iterator& x, const move_sentinel<S>& y);
    friend constexpr iter_rvalue_reference_t<Iter>
      iter_move(const move_iterator& i)
        noexcept(noexcept(ranges::iter_move(i.current)));
    template<indirectly_swappable<Iter> Iter2>
      friend constexpr void
        iter_swap(const move_iterator& x, const move_iterator<Iter2>& y)
          noexcept(noexcept(ranges::iter_swap(x.current, y.current)));
  private:
    Iter current;     // 설명 전용
  };
}

클래스 템플릿 std::move_sentinel 

namespace std {
  template<semiregular S>
  class move_sentinel {
  public:
    constexpr move_sentinel();
    constexpr explicit move_sentinel(S s);
    template<class S2>
      requires convertible_to<const S2&, S>
        constexpr move_sentinel(const move_sentinel<S2>& s);
    template<class S2>
      requires assignable_from<S&, const S2&>
        constexpr move_sentinel& operator=(const move_sentinel<S2>& s);
    constexpr S base() const;
  private:
    S last;     // 설명 전용
  };
}

클래스 템플릿 std::common_iterator 

namespace std {
  template<input_or_output_iterator I, sentinel_for<I> S>
    requires (!same_as<I, S> && copyable<I>)
  class common_iterator {
  public:
    constexpr common_iterator() = default;
    constexpr common_iterator(I i);
    constexpr common_iterator(S s);
    template<class I2, class S2>
      requires convertible_to<const I2&, I> && convertible_to<const S2&, S>
        constexpr common_iterator(const common_iterator<I2, S2>& x);
    template<class I2, class S2>
      requires convertible_to<const I2&, I> && convertible_to<const S2&, S> &&
               assignable_from<I&, const I2&> && assignable_from<S&, const S2&>
        common_iterator& operator=(const common_iterator<I2, S2>& x);
    decltype(auto) operator*();
    decltype(auto) operator*() const
      requires dereferenceable<const I>;
    decltype(auto) operator->() const
      requires /* 설명 참조 */;
    common_iterator& operator++();
    decltype(auto) operator++(int);
    template<class I2, sentinel_for<I> S2>
      requires sentinel_for<S, I2>
    friend bool operator==(
      const common_iterator& x, const common_iterator<I2, S2>& y);
    template<class I2, sentinel_for<I> S2>
      requires sentinel_for<S, I2> && equality_comparable_with<I, I2>
    friend bool operator==(
      const common_iterator& x, const common_iterator<I2, S2>& y);
    template<sized_sentinel_for<I> I2, sized_sentinel_for<I> S2>
      requires sized_sentinel_for<S, I2>
    friend iter_difference_t<I2> operator-(
      const common_iterator& x, const common_iterator<I2, S2>& y);
    friend constexpr decltype(auto) iter_move(const common_iterator& i)
      noexcept(noexcept(ranges::iter_move(declval<const I&>())))
        requires input_iterator<I>;
    template<indirectly_swappable<I> I2, class S2>
      friend void iter_swap(const common_iterator& x, const common_iterator<I2, S2>& y)
        noexcept(noexcept(ranges::iter_swap
(설명: HTML 태그와 속성은 그대로 유지되었으며, C++ 관련 용어인 "ranges::iter_swap"은 번역되지 않았습니다. 전체 링크 텍스트가 C++ 관련 용어로 구성되어 있어 번역 대상이 없습니다.)(declval<const I&>(), declval<const I2&>())));
  private:
    variant<I, S> v_;   // 설명 전용
  };
  template<class I, class S>
  struct incrementable_traits<common_iterator<I, S>> {
    using difference_type = iter_difference_t<I>;
  };
  template<input_iterator I, class S>
  struct iterator_traits<common_iterator<I, S>> {
    using iterator_concept = /* 설명 참조 */;
    using iterator_category = /* 설명 참조 */;
    using value_type = iter_value_t<I>;
    using difference_type = iter_difference_t<I>;
    using pointer = /* 설명 참조 */;
    using reference = iter_reference_t<I>;
  };
}

클래스 std::default_sentinel_t 

namespace std {
  struct default_sentinel_t { };
}

클래스 템플릿 std::counted_iterator 

namespace std {
  template<input_or_output_iterator I>
  class counted_iterator {
  public:
    using iterator_type = I;
    constexpr counted_iterator() = default;
    constexpr counted_iterator(I x, iter_difference_t<I> n);
    template<class I2>
      requires convertible_to<const I2&, I>
        constexpr counted_iterator(const counted_iterator<I2>& x);
    template<class I2>
      requires assignable_from<I&, const I2&>
        constexpr counted_iterator& operator=(const counted_iterator<I2>& x);
    constexpr I base() const & requires copy_constructible<I>;
    constexpr I base() &&;
    constexpr iter_difference_t<I> count() const noexcept;
    constexpr decltype(auto) operator*();
    constexpr decltype(auto) operator*() const
      requires dereferenceable<const I>;
    constexpr auto operator->() const noexcept
      requires contiguous_iterator<I>;
    constexpr counted_iterator& operator++();
    decltype(auto) operator++(int);
    constexpr counted_iterator operator++(int)
      requires forward_iterator<I>;
    constexpr counted_iterator& operator--()
      requires bidirectional_iterator<I>;
    constexpr counted_iterator operator--(int)
      requires bidirectional_iterator<I>;
    constexpr counted_iterator operator+(iter_difference_t<I> n) const
      requires random_access_iterator<I>;
    friend constexpr counted_iterator operator+(
      iter_difference_t<I> n, const counted_iterator& x)
        requires random_access_iterator<I>;
    constexpr counted_iterator& operator+=(iter_difference_t<I> n)
      requires random_access_iterator<I>;
    constexpr counted_iterator operator-(iter_difference_t<I> n) const
      requires random_access_iterator<I>;
    template<common_with<I> I2>
      friend constexpr iter_difference_t<I2> operator-(
        const counted_iterator& x, const counted_iterator<I2>& y);
    friend constexpr iter_difference_t<I> operator-(
      const counted_iterator& x, default_sentinel_t);
    friend constexpr iter_difference_t<I> operator-(
      default_sentinel_t, const counted_iterator& y);
    constexpr counted_iterator& operator-=(iter_difference_t<I> n)
      requires random_access_iterator<I>;
    constexpr decltype(auto) operator[](iter_difference_t<I> n) const
      requires random_access_iterator<I>;
    template<common_with<I> I2>
      friend constexpr bool operator==(
        const counted_iterator& x, const counted_iterator<I2>& y);
    friend constexpr bool operator==(
      const counted_iterator& x, default_sentinel_t);
    template<common_with<I> I2>
      friend constexpr strong_ordering operator<=>(
        const counted_iterator& x, const counted_iterator<I2>& y);
    friend constexpr decltype(auto) iter_move(const counted_iterator& i)
      noexcept(noexcept(ranges::iter_move(i.current)))
        requires input_iterator<I>;
    template<indirectly_swappable<I> I2>
      friend constexpr void iter_swap(const counted_iterator& x,
                                      const counted_iterator<I2>& y)
        noexcept(noexcept(ranges::iter_swap
(HTML 태그와 속성은 번역하지 않고 원본 형식을 유지하며, , 
,  태그 내 텍스트는 번역하지 않으며, C++ 관련 용어는 번역하지 않음)
(x.current, y.current)));
  private:
    I current = I();                    // 설명 전용
    iter_difference_t<I> length = 0;    // 설명 전용
  };
  template<input_iterator I>
  struct iterator_traits<counted_iterator<I>> : iterator_traits<I> {
    using pointer = void;
  };
}

클래스 std::unreachable_sentinel_t 

namespace std {
  struct unreachable_sentinel_t {
    template<weakly_incrementable I>
      friend constexpr bool operator==(unreachable_sentinel_t, const I&) noexcept
      { return false; }
  };
}

클래스 템플릿 std::istream_iterator 

namespace std {
  template<class T, class CharT = char, class Traits = char_traits<CharT>,
           class Distance = ptrdiff_t>
  class istream_iterator {
  public:
    using iterator_category = input_iterator_tag;
    using value_type        = T;
    using difference_type   = Distance;
    using pointer           = const T*;
    using reference         = const T&;
    using char_type         = CharT;
    using traits_type       = Traits;
    using istream_type      = basic_istream<CharT, Traits>;
    constexpr istream_iterator();
    constexpr istream_iterator(default_sentinel_t);
    istream_iterator(istream_type& s);
    istream_iterator(const istream_iterator& x) = default;
    ~istream_iterator() = default;
    istream_iterator& operator=(const istream_iterator&) = default;
    const T& operator*() const;
    const T* operator->() const;
    istream_iterator& operator++();
    istream_iterator  operator++(int);
    friend bool operator==(const istream_iterator& i, default_sentinel_t);
  private:
    basic_istream<CharT, Traits>* in_stream; // 설명 전용
    T value;                                 // 설명 전용
  };
}

클래스 템플릿 std::ostream_iterator 

namespace std {
  template<class T, class CharT = char, classTraits = char_traits<CharT>>
  class ostream_iterator {
  public:
    using iterator_category = output_iterator_tag;
    using value_type        = void;
    using difference_type   = ptrdiff_t;
    using pointer           = void;
    using reference         = void;
    using char_type         = CharT;
    using traits_type       = Traits;
    using ostream_type      = basic_ostream<CharT, Traits>;
    constexpr ostreambuf_iterator() noexcept = default;
    ostream_iterator(ostream_type& s);
    ostream_iterator(ostream_type& s, const CharT* delimiter);
    ostream_iterator(const ostream_iterator& x);
    ~ostream_iterator();
    ostream_iterator& operator=(const ostream_iterator&) = default;
    ostream_iterator& operator=(const T& value);
    ostream_iterator& operator*();
    ostream_iterator& operator++();
    ostream_iterator& operator++(int);
  private:
    basic_ostream<CharT, Traits>* out_stream = nullptr;          // 설명 전용
    const CharT* delim = nullptr;                                // 설명 전용
  };
}

클래스 템플릿 std::istreambuf_iterator 

namespace std {
  template<class CharT, class Traits = char_traits<CharT>>
  class istreambuf_iterator {
  public:
    using iterator_category = input_iterator_tag;
    using value_type        = CharT;
    using difference_type   = typename Traits::off_type;
    using pointer           = /* 지정되지 않음 */;
    using reference         = CharT;
    using char_type         = CharT;
    using traits_type       = Traits;
    using int_type          = typename Traits::int_type;
    using streambuf_type    = basic_streambuf<CharT, Traits>;
    using istream_type      = basic_istream<CharT, Traits>;
    class proxy;                          // 설명 전용
    constexpr istreambuf_iterator() noexcept;
    constexpr istreambuf_iterator(default_sentinel_t) noexcept;
    istreambuf_iterator(const istreambuf_iterator&) noexcept = default;
    ~istreambuf_iterator() = default;
    istreambuf_iterator(istream_type& s) noexcept;
    istreambuf_iterator(streambuf_type* s) noexcept;
    istreambuf_iterator(const proxy& p) noexcept;
    istreambuf_iterator& operator=(const istreambuf_iterator&) noexcept = default;
    CharT operator*() const;
    istreambuf_iterator& operator++();
    proxy operator++(int);
    bool equal(const istreambuf_iterator& b) const;
    friend bool operator==(const istreambuf_iterator& i, default_sentinel_t s);
  private:
    streambuf_type* sbuf_;                // 설명 전용
  };
  template<class CharT, class Traits>
  class istreambuf_iterator<CharT, Traits>::proxy { // 설명 전용
    CharT keep_;
    basic_streambuf<CharT, Traits>* sbuf_;
    proxy(CharT c, basic_streambuf<CharT, Traits>* sbuf)
      : keep_(c), sbuf_(sbuf) { }
  public:
    CharT operator*() { return keep_; }
  };
}

클래스 템플릿 std::ostreambuf_iterator 

namespace std {
  template<class CharT, class Traits = char_traits<CharT>>
  class ostreambuf_iterator {
  public:
    using iterator_category = output_iterator_tag;
    using value_type        = void;
    using difference_type   = ptrdiff_t;
    using pointer           = void;
    using reference         = void;
    using char_type         = CharT;
    using traits_type       = Traits;
    using streambuf_type    = basic_streambuf<CharT, Traits>;
    using ostream_type      = basic_ostream<CharT, Traits>;
    constexpr ostreambuf_iterator() noexcept = default;
    ostreambuf_iterator(ostream_type& s) noexcept;
    ostreambuf_iterator(streambuf_type* s) noexcept;
    ostreambuf_iterator& operator=(CharT c);
    ostreambuf_iterator& operator*();
    ostreambuf_iterator& operator++();
    ostreambuf_iterator& operator++(int);
    bool failed() const noexcept;
  private:
    streambuf_type* sbuf_ = nullptr;    // 설명용으로만 사용
  };
}

클래스 템플릿 std::iterator 

namespace std {
  template<class Category, class T, class Distance = ptrdiff_t,
           class Pointer = T*, class Reference = T&>
  struct iterator {
    typedef Category  iterator_category;
    typedef T         value_type;
    typedef Distance  difference_type;
    typedef Pointer   pointer;
    typedef Reference reference;
  };
}

결함 보고서

다음의 동작 변경 결함 보고서들은 이전에 발표된 C++ 표준에 소급 적용되었습니다.

DR 적용 대상 게시된 동작 올바른 동작
LWG 349 C++98 설명 전용 멤버 delim 의
std::ostream_iterator 타입이 const char * 임 		const CharT * 로 수정됨