Заголовочный файл стандартной библиотеки <iterator>

Этот заголовочный файл - часть библиотеки итераторов.

Этот заголовок является частично автономным заголовком. Все, что находится внутри этого заголовка, находится отдельно от итераторов потоков.

(начиная с C++23)

Шаблон:cpp/iterator/dsc projected value t Шаблон:cpp/iterator/dsc unreachable sentinel Шаблон:cpp/iterator/dsc default sentinel

Содержание 1 Концепты 1.1 Концепты итераторов 1.2 Indirect callable concepts 1.3 Общие требования к алгоритмам 2 Классы 2.1 Algorithm utilities 2.2 Ассоцированные типы 2.3 Примитивы 2.4 Адапторы 2.5 Итераторы потоков 3 Customization point objects 4 Константы 5 Функции 5.1 Адапторы 5.2 Non-member operators 5.3 Операции 5.4 Range access 6 Synopsis 6.1 Концепт indirectly_readable 6.2 Концепт indirectly_writable 6.3 Концепт weakly_incrementable 6.4 Концепт incrementable 6.5 Концепт input_or_output_iterator 6.6 Концепт sentinel_for 6.7 Концепт sized_sentinel_for 6.8 Концепт input_iterator 6.9 Концепт output_iterator 6.10 Концепт forward_iterator 6.11 Концепт bidirectional_iterator 6.12 Концепт random_access_iterator 6.13 Концепт contiguous_iterator 6.14 Концепт indirectly_unary_invocable 6.15 Концепт indirectly_regular_unary_invocable 6.16 Концепт indirect_unary_predicate 6.17 Концепт indirect_binary_predicate 6.18 Концепт indirect_equivalence_relation 6.19 Концепт indirect_strict_weak_order 6.20 Концепт indirectly_movable 6.21 Концепт indirectly_movable_storable 6.22 Концепт indirectly_copyable 6.23 Концепт indirectly_copyable_storable 6.24 Концепт indirectly_swappable 6.25 Концепт indirectly_comparable 6.26 Концепт permutable 6.27 Концепт mergeable 6.28 Концепт sortable 6.29 Шаблонный класс std::incrementable_traits 6.30 Шаблонный класс std::indirectly_readable_traits 6.31 Шаблонный класс std::projected 6.32 Шаблонный класс std::iterator_traits 6.33 Iterator tags 6.34 Шаблонный класс std::reverse_iterator 6.35 Шаблонный класс std::back_insert_iterator 6.36 Шаблонный класс std::front_insert_iterator 6.37 Шаблонный класс std::insert_iterator 6.38 Шаблонный класс std::move_iterator 6.39 Шаблонный класс std::move_sentinel 6.40 Шаблонный класс std::common_iterator 6.41 Класс std::default_sentinel_t 6.42 Шаблонный класс std::counted_iterator 6.43 Класс std::unreachable_sentinel_t 6.44 Шаблонный класс std::istream_iterator 6.45 Шаблонный класс std::ostream_iterator 6.46 Шаблонный класс std::istreambuf_iterator 6.47 Шаблонный класс std::ostreambuf_iterator 6.48 Шаблонный класс std::iterator 7 Defect reports Концепты
Концепты итераторов
indirectly_readable (C++20)	указывает, что тип доступен для чтения косвенно с помощью оператора `*` (концепт) [править]
indirectly_writable (C++20)	указывает, что значение может быть записано в объект, на который указывает ссылка итератора (концепт) [править]
weakly_incrementable (C++20)	указывает, что тип `semiregular` может увеличиваться с помощью операторов до и после инкремента (концепт) [править]
incrementable (C++20)	указывает, что операция инкремента для типа `weakly_incrementable` сохраняет равенство и что этот тип является `equality_comparable` (концепт) [править]
input_or_output_iterator (C++20)	указывает, что объекты типа могут быть инкрементированы и разыменованы (концепт) [править]
sentinel_for (C++20)	указывает, что тип является ограничителем для типа `input_or_output_iterator` (концепт) [править]
sized_sentinel_for (C++20)	указывает, что оператор `-` может быть применён к итератору и ограничителю, чтобы вычислить их разницу за постоянное время (концепт) [править]
input_iterator (C++20)	указывает, что тип является итератором ввода, то есть значения, на которые он ссылается, могут быть прочитаны, и он может быть как пре-инкрементирован, так и пост-инкрементирован (концепт) [править]
output_iterator (C++20)	указывает, что тип является итератором вывода для данного типа значения, то есть в него могут быть записаны значения этого типа, и он может быть как пре-, так и пост-инкрементирован (концепт) [править]
forward_iterator (C++20)	указывает, что `input_iterator` является прямым итератором, поддерживающим сравнение на равенство и многопроходность (концепт) [править]
bidirectional_iterator (C++20)	указывает, что `forward_iterator` является двунаправленным итератором, поддерживающим движение назад (концепт) [править]
random_access_iterator (C++20)	указывает, что `bidirectional_iterator` это итератор с произвольным доступом, поддерживающий продвижение за постоянное время и индексирование (концепт) [править]
contiguous_iterator (C++20)	указывает, что `random_access_iterator` является непрерывным итератором, ссылающимся на смежные элементы памяти (концепт) [править]
Indirect callable concepts
indirectly_unary_invocableindirectly_regular_unary_invocable (C++20)(C++20)	указывает, что вызываемый тип может быть вызван в результате разыменования типа `indirectly_readable` (концепт) [править]
indirect_unary_predicate (C++20)	указывает, что вызываемый тип, когда он вызывается с результатом разыменования типа `indirectly_readable`, соответствует `predicate` (концепт) [править]
indirect_binary_predicate (C++20)	указывает, что вызываемый тип, когда он вызывается с результатом разыменования двух типов `indirectly_readable`, соответствует `predicate` (концепт) [править]
indirect_equivalence_relation (C++20)	указывает, что вызываемый тип при вызове в результате разыменования двух типов `indirectly_readable`, соответствует `equivalence_relation` (концепт) [править]
indirect_strict_weak_order (C++20)	указывает, что вызываемый тип, когда он вызывается с результатом разыменования двух типов `indirectly_readable`, соответствует `strict_weak_order` (концепт) [править]
Общие требования к алгоритмам
indirectly_movable (C++20)	указывает, что значения могут быть перемещены из типа `indirectly_readable` в тип `indirectly_writable` (концепт) [править]
indirectly_movable_storable (C++20)	указывает, что значения могут быть перемещены из типа `indirectly_readable` в тип `indirectly_writable` и что перемещение может быть выполнено через промежуточный объект (концепт) [править]
indirectly_copyable (C++20)	указывает, что значения могут быть скопированы из типа `indirectly_readable` в тип `indirectly_writable` (концепт) [править]
indirectly_copyable_storable (C++20)	указывает, что значения могут быть скопированы из типа `indirectly_readable` в тип `indirectly_writable` что копирование может быть выполнено через промежуточный объект (концепт) [править]
indirectly_swappable (C++20)	указывает, что значения, на которые ссылаются два типа `indirectly_readable`, можно поменять местами (концепт) [править]
indirectly_comparable (C++20)	указывает, что значения, на которые ссылаются два типа `indirectly_readable`, могут сравниваться (концепт) [править]
permutable (C++20)	определяет общие требования к алгоритмам, которые меняют порядок элементов на месте (концепт) [править]
mergeable (C++20)	определяет требования к алгоритмам, которые объединяют отсортированные последовательности в выходную последовательность путём копирования элементов (концепт) [править]
sortable (C++20)	определяет общие требования алгоритмов, которые переставляют последовательности в упорядоченные последовательности (концепт) [править]
Классы
Algorithm utilities
indirect_result_t (C++20)	вычисляет результат вызова вызываемого объекта на результате разыменования некоторого набора типов `indirectly_readable` (псевдоним шаблона) [править]
projected (C++20)	вспомогательный шаблон для определения ограничений для алгоритмов, принимающих прогнозы (шаблон класса) [править]
Ассоцированные типы
incrementable_traits (C++20)	вычисляет разностный тип типа `weakly_incrementable` (шаблон класса) [править]
indirectly_readable_traits (C++20)	вычисляет тип значения типа `indirectly_readable` (шаблон класса) [править]
iter_value_titer_reference_titer_const_reference_titer_difference_titer_rvalue_reference_titer_common_reference_t (C++20)(C++20)(C++23)(C++20)(C++20)(C++20)	вычисляет связанные типы итератора (псевдоним шаблона) [править]
Примитивы
iterator_traits	предоставляет единый интерфейс к свойствам итератора (шаблон класса) [править]
input_iterator_tagoutput_iterator_tagforward_iterator_tagbidirectional_iterator_tagrandom_access_iterator_tagcontiguous_iterator_tag (C++20)	пустые типы классов, используемые для обозначения категорий итераторов (класс) [править]
iterator (устарело в C++17)	базовый класс для упрощения определения требуемых типов для простых итераторов (шаблон класса) [править]
Адапторы
reverse_iterator	адаптер итератора для обхода в обратном порядке (шаблон класса) [править]
move_iterator (C++11)	адаптер итератора, который разыменовывается в правостороннюю ссылку (шаблон класса) [править]
move_sentinel (C++20)	адаптер ограничитель для использования с std::move_iterator (шаблон класса) [править]
basic_const_iterator (C++23)	адаптер итератора, который преобразует итератор в константный итератор (шаблон класса) [править]
const_iterator (C++23)	вычисляет константный тип итератора для заданного типа (псевдоним шаблона) [править]
const_sentinel (C++23)	вычисляет тип ограничителя, который будет использоваться с константными итераторами (псевдоним шаблона) [править]
common_iterator (C++20)	адаптирует тип итератора и его ограничителя к общему типу итератора (шаблон класса) [править]
default_sentinel_t (C++20)	ограничитель по умолчанию для использования с итераторами, которые знают границу своего диапазона (класс) [править]
counted_iterator (C++20)	адаптер итератора, отслеживающий расстояние до конца диапазона (шаблон класса) [править]
unreachable_sentinel_t (C++20)	ограничитель, который всегда сравнивает на неравенство с любым типом `weakly_incrementable` (класс) [править]
back_insert_iterator	адаптер итератора для вставки в конец контейнера (шаблон класса) [править]
front_insert_iterator	адаптер итератора для вставки в начало контейнера (шаблон класса) [править]
insert_iterator	адаптер итератора для вставки в контейнер (шаблон класса) [править]
Итераторы потоков
istream_iterator	итератор ввода, читающий из std::basic_istream (шаблон класса) [править]
ostream_iterator	итератор вывода, записывающий в std::basic_ostream (шаблон класса) [править]
istreambuf_iterator	итератор ввода, читающий из std::basic_streambuf (шаблон класса) [править]
ostreambuf_iterator	итератор вывода, записывающий в std::basic_streambuf (шаблон класса) [править]
Customization point objects
Определены в пространстве имён `std::ranges`
iter_move (C++20)	приводит результат разыменования объекта к связанному с ним типу правосторонней ссылки (объект точки настройки) [править]
iter_swap (C++20)	меняет местами значения, на которые ссылаются два разыменовываемых объекта (объект точки настройки) [править]
Константы
Функции
Адапторы
make_reverse_iterator (C++14)	создаёт std::reverse_iterator типа, выведенного из аргумента (шаблон функции) [править]
make_move_iterator (C++11)	создаёт std::move_iterator типа, выведенного из аргумента (шаблон функции) [править]
make_const_iterator (C++23)	создаёт std::const_iterator типа, полученного из аргумента (шаблон функции) [править]
make_const_sentinel (C++23)	создаёт std::const_sentinel типа, выведенного из аргумента (шаблон функции) [править]
front_inserter	создаёт std::front_insert_iterator типа, выведенного из аргумента (шаблон функции) [править]
back_inserter	создаёт std::back_insert_iterator типа, выведенного из аргумента (шаблон функции) [править]
inserter	создаёт std::insert_iterator типа, выведенного из аргумента (шаблон функции) [править]
Non-member operators
operator==operator!=operator<operator<=operator>operator>=operator<=> (C++11)(C++11)(удалено в C++20)(C++11)(C++11)(C++11)(C++11)(C++20)	сравнивает базовые итераторы (шаблон функции) [править]
operator+	перемещает итератор Оригинал: advances the iterator Текст был переведён автоматически используя Переводчик Google. Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда. (шаблон функции) [править]
operator-	вычисляет расстояние между двумя адаптерами итераторов Оригинал: computes the distance between two iterator adaptors Текст был переведён автоматически используя Переводчик Google. Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда. (шаблон функции) [править]
operator==operator!=operator<operator<=operator>operator>=operator<=> (C++20)	сравнивает базовые итераторы (шаблон функции) [править]
operator+	перемещает итератор Оригинал: advances the iterator Текст был переведён автоматически используя Переводчик Google. Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда. (шаблон функции) [править]
operator-	вычисляет расстояние между двумя адаптерами итераторов Оригинал: computes the distance between two iterator adaptors Текст был переведён автоматически используя Переводчик Google. Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда. (шаблон функции) [править]
operator==operator<=> (C++20)	сравнивает расстояния до конца (шаблон функции) [править]
operator+	перемещает итератор Оригинал: advances the iterator Текст был переведён автоматически используя Переводчик Google. Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда. (шаблон функции) [править]
operator-	вычисляет расстояние между двумя адаптерами итераторов Оригинал: computes the distance between two iterator adaptors Текст был переведён автоматически используя Переводчик Google. Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда. (шаблон функции) [править]
operator==operator!= (удалено в C++20)	сравнивает два `istream_iterator` (шаблон функции) [править]
operator==operator!= (удалено в C++20)	сравнивает два `istreambuf_iterator` (шаблон функции) [править]
Операции
advance	продвигает итератор на заданное расстояние (функция) [править]
distance	возвращает расстояние между двумя итераторами (функция) [править]
next (C++11)	инкрементирует итератор (функция) [править]
prev (C++11)	декрементирует итератор (функция) [править]
ranges::advance (C++20)	продвигает итератор на заданное расстояние или до заданной границы (ниблоид) [править]
ranges::distance (C++20)	возвращает расстояние между итератором и ограничителем или между началом и концом диапазона (ниблоид) [править]
ranges::next (C++20)	инкрементирует итератор на заданное расстояние или до границы (ниблоид) [править]
ranges::prev (C++20)	декрементирует итератор на заданное расстояние или до границы (ниблоид) [править]
Range access
begincbegin (C++11)(C++14)	возвращает итератор на начало контейнера или массива (шаблон функции) [править]
endcend (C++11)(C++14)	возвращает итератор на конец контейнера или массива (шаблон функции) [править]
rbegincrbegin (C++14)	возвращает обратный итератор на начало контейнера или массива (шаблон функции) [править]
rendcrend (C++14)	возвращает обратный конечный итератор для контейнера или массива (шаблон функции) [править]
sizessize (C++17)(C++20)	возвращает размер контейнера или массива (шаблон функции) [править]
empty (C++17)	проверяет, пустой ли контейнер (шаблон функции) [править]
data (C++17)	получает указатель на базовый массив (шаблон функции) [править]

Synopsis

#include <compare>
#include <concepts>

namespace std {
  template<class T> using /* со_ссылкой */ = T&;   // только для примера
  template<class T> concept /* может_ссылаться */  // только для примера
    = requires { typename /* со_ссылкой */<T>; };
  template<class T> concept /* разыменовываемый */ // только для примера
    = requires(T& t) {
      { *t } -> /* можно_разыменовывать */;  // не обязательно сохранять равенство типов
    };

  // связанные типы
  // свойство 'incrementable'
  template<class> struct incrementable_traits;
  template<class T>
    using iter_difference_t = /* см. описание */;

  // свойство 'indirectly readable'
  template<class> struct indirectly_readable_traits;
  template<class T>
    using iter_value_t = /* см. описание */;

  // свойства итераторов
  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 /* unspecified */ {
      // ranges::iter_move
      inline constexpr /* unspecified */ iter_move = /* unspecified */;

      // ranges::iter_swap
      inline constexpr /* unspecified */ iter_swap = /* unspecified */;
    }
  }

  template</* разыменовываемый */ T>
    requires requires(T& t) {
      { ranges::iter_move(t) } -> /* со_ссылкой */;
    }
  using iter_rvalue_reference_t
    = decltype(ranges::iter_move(declval<T&>()));

  // iterator concepts
  // концепт 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>&>;

  // концепт indirectly_writable
  template<class Out, class T>
    concept indirectly_writable = /* см. описание */;

  // концепт weakly_incrementable
  template<class I>
    concept weakly_incrementable = /* см. описание */;

  // концепт incrementable
  template<class I>
    concept incrementable = /* см. описание */;

  // концепт input_or_output_iterator
  template<class I>
    concept input_or_output_iterator = /* см. описание */;

  // концепт sentinel_for
  template<class S, class I>
    concept sentinel_for = /* см. описание */;

  // концепт 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 = /* см. описание */;

  // концепт input_iterator
  template<class I>
    concept input_iterator = /* см. описание */;

  // концепт output_iterator
  template<class I, class T>
    concept output_iterator = /* см. описание */;

  // концепт forward_iterator
  template<class I>
    concept forward_iterator = /* см. описание */;

  // концепт bidirectional_iterator
  template<class I>
    concept bidirectional_iterator = /* см. описание */;

  // концепт random_access_iterator
  template<class I>
    concept random_access_iterator = /* см. описание */;

  // концепт contiguous_iterator
  template<class I>
    concept contiguous_iterator = /* см. описание */;

  // indirect callable requirements
  // indirect callables
  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>
    struct projected;

  template<weakly_incrementable I, class Proj>
    struct incrementable_traits<projected<I, Proj>>;

  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>&>>;

  // common algorithm requirements
  // концепт indirectly_movable
  template<class In, class Out>
    concept indirectly_movable = /* см. описание */;

  template<class In, class Out>
    concept indirectly_movable_storable = /* см. описание */;

  // концепт indirectly_copyable
  template<class In, class Out>
    concept indirectly_copyable = /* см. описание */;

  template<class In, class Out>
    concept indirectly_copyable_storable = /* см. описание */;

  // концепт indirectly_swappable
  template<class I1, class I2 = I1>
    concept indirectly_swappable = /* см. описание */;

  // концепт indirectly_comparable
  template<class I1, class I2, class R, class P1 = identity, class P2 = identity>
    concept indirectly_comparable = /* см. описание */;

  // концепт permutable
  template<class I>
    concept permutable = /* см. описание */;

  // концепт mergeable
  template<class I1, class I2, class Out,
      class R = ranges::less, class P1 = identity, class P2 = identity>
    concept mergeable = /* см. описание */;

  // концепт 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);
  }

  // predefined iterators and sentinels
  // 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;

  // common iterators
  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>>;

  // default sentinel
  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>>;

  // unreachable sentinel
  struct unreachable_sentinel_t;
  inline constexpr unreachable_sentinel_t unreachable_sentinel{};

  // stream iterators
  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;

  // range access
  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); // not required to be equality-preserving
        *std::forward<Out>(o) = std::forward<T>(t);
        // not required to be equality-preserving
        const_cast<const iter_reference_t<Out>&&>(*o) =
        std::forward<T>(t); // not required to be equality-preserving
        const_cast<const iter_reference_t<Out>&&>(*std::forward<Out>(o)) =
        std::forward<T>(t); // not required to be equality-preserving
      };
}

Концепт `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&>;   // not required to be equality-preserving
        i++;                      // not required to be equality-preserving
      };
}

Концепт `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 } -> /* со_ссылкой */;
      } &&
      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); // not required to be equality-preserving
      };
}

Концепт `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<indirectly_readable I, indirectly_regular_unary_invocable<I> Proj>
  struct projected {
    using value_type = remove_cvref_t<indirect_result_t<Proj&, I>>;
    indirect_result_t<Proj&, I> operator*() const; // не определён
  };

  template<weakly_incrementable I, class Proj>
  struct incrementable_traits<projected<I, Proj>> {
    using difference_type = iter_difference_t<I>;
  };
}

Шаблонный класс 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&;
  };
}

Iterator tags

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 /* unspecified */ 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(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(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           = /* unspecified */;
    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;
  };
}

Defect reports

Следующие изменения поведения были применены с обратной силой к ранее опубликованным стандартам C++:

Номер	Применён	Поведение в стандарте	Корректное поведение
LWG 349	C++98	the exposition-only member `delim` of std::ostream_iterator had type `const char*`	corrected to `const CharT*`

Поддержка компилятором
Автономные и размещённые реализации
Язык
Стандартная библиотека
Заголовки стандартной библиотеки
Требования к именованию
Макросы тестирования функциональности (C++20)
Поддержка языка
Библиотека концептов (C++20)
Библиотека метапрограммирования (C++11)
Библиотека диагностики
Библиотека общих утилит
Библиотека строк
Библиотека контейнеров
Библиотека итераторов
Библиотека диапазонов (C++20)
Библиотека алгоритмов
Библиотека численных данных
Библиотека ввода/вывода
Библиотека локализаций
Регулярные выражения (C++11)
Атомарные операции (C++11)
Библиотека поддержки конкуренции (C++11)
Библиотека файловой системы (C++17)
Технические спецификации
Указатель символов
Внешние библиотеки

cppreference.com

Поиск

Пространства имён

Варианты

Просмотры

Действия

Заголовочный файл стандартной библиотеки <iterator>

Концепты

Концепты итераторов

Indirect callable concepts

Общие требования к алгоритмам

Классы

Algorithm utilities

Ассоцированные типы

Примитивы

Адапторы

Итераторы потоков

Customization point objects

Константы

Функции

Адапторы

Non-member operators

Операции

Range access

Synopsis

Концепт indirectly_readable

Концепт indirectly_writable

Концепт weakly_incrementable

Концепт incrementable

Концепт input_or_output_iterator

Концепт sentinel_for

Концепт sized_sentinel_for

Концепт input_iterator

Концепт output_iterator

Концепт forward_iterator

Концепт bidirectional_iterator

Концепт random_access_iterator

Концепт contiguous_iterator

Концепт indirectly_unary_invocable

Концепт indirectly_regular_unary_invocable

Концепт indirect_unary_predicate

Концепт indirect_binary_predicate

Концепт indirect_equivalence_relation

Концепт indirect_strict_weak_order

Концепт indirectly_movable

Концепт indirectly_movable_storable

Концепт indirectly_copyable

Концепт indirectly_copyable_storable

Концепт indirectly_swappable

Концепт indirectly_comparable

Концепт permutable

Концепт mergeable

Концепт sortable