Standard library header <iterator>

From cppreference.net

Этот заголовок является частью библиотеки итераторов .

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

(since C++23)

Содержание

Концепции

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

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)

определяет, что тип является sentinel для типа


           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

является непрерывным итератором, ссылающимся на элементы, расположенные непрерывно в памяти
(концепт)

Концепции косвенно вызываемых объектов

indirectly_unary_invocable indirectly_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)

определяет требования алгоритмов, которые объединяют отсортированные последовательности в выходную последовательность путем копирования элементов
(concept)

sortable

(C++20)

определяет общие требования алгоритмов, которые переставляют последовательности в упорядоченные последовательности
(концепт)

Классы

Утилиты алгоритмов

indirect_result_t

(C++20)

вычисляет результат вызова вызываемого объекта на результате разыменования некоторого набора


           indirectly_readable

типов
(псевдоним шаблона)

projected

(C++20)

вспомогательный шаблон для указания ограничений на алгоритмы, принимающие проекции
(псевдоним шаблона)

projected_value_t

(C++26)

вычисляет тип значения


           indirectly_readable

типа через проекцию
(псевдоним шаблона)

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

incrementable_traits

(C++20)

вычисляет тип разности для


           weakly_incrementable

типа
(шаблон класса)

indirectly_readable_traits

(C++20)

вычисляет тип значения для


           indirectly_readable

типа
(шаблон класса)

iter_value_t iter_reference_t iter_const_reference_t iter_difference_t iter_rvalue_reference_t iter_common_reference_t

(C++20) (C++20) (C++23) (C++20) (C++20) (C++20)

вычисляет связанные типы итератора
(псевдоним шаблона)

Примитивы

iterator_traits

предоставляет унифицированный интерфейс к свойствам итератора
(шаблон класса)

input_iterator_tag output_iterator_tag forward_iterator_tag bidirectional_iterator_tag random_access_iterator_tag contiguous_iterator_tag

(C++20)

пустые типы классов, используемые для обозначения категорий итераторов
(класс)

iterator

(deprecated in C++17)

базовый класс для упрощения определения требуемых типов для простых итераторов
(class template)

Адаптеры

reverse_iterator

адаптер итератора для обхода в обратном порядке
(шаблон класса)

move_iterator

(C++11)

адаптер итератора, который разыменовывается в rvalue
(шаблон класса)

move_sentinel

(C++20)

адаптер sentinel для std::move_iterator
(шаблон класса)

basic_const_iterator

(C++23)

адаптер итератора, преобразующий итератор в константный итератор
(шаблон класса)

const_iterator

(C++23)

вычисляет тип константного итератора для заданного типа
(псевдоним шаблона)

const_sentinel

(C++23)

вычисляет тип sentinel для использования с константными итераторами
(alias template)

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
(шаблон класса)

Объекты точек кастомизации

Определено в пространстве имён


           std::ranges

iter_move

(C++20)

преобразует результат разыменования объекта в связанный с ним тип rvalue-ссылки
(объект точки кастомизации)

iter_swap

(C++20)

обменивает значения, на которые ссылаются два разыменовываемых объекта
(объект точки кастомизации)

Константы

unreachable_sentinel

(C++20)

объект типа


          unreachable_sentinel_t

который всегда сравнивается как неравный с любым


           weakly_incrementable

типом
(константа)

default_sentinel

(C++20)

объект типа


          default_sentinel_t

используемый с итераторами, которые знают границу своего диапазона
(константа)

Функции

Адаптеры

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 типа, выведенного из аргумента
(шаблон функции)

Нечленные операторы

operator== operator!= operator< operator<= operator> operator>= operator<=>

(C++11) (C++11) (removed in C++20) (C++11) (C++11) (C++11) (C++11) (C++20)

сравнивает базовые итераторы
(шаблон функции)

operator+

(C++11)

перемещает итератор вперед
(шаблон функции)

operator-

(C++11)

вычисляет расстояние между двумя адаптерами итераторов
(шаблон функции)

operator== operator!= operator< operator<= operator> operator>= operator<=>

(C++20)

сравнивает базовые итераторы
(шаблон функции)

operator+

перемещает итератор вперед
(шаблон функции)

operator-

вычисляет расстояние между двумя адаптерами итераторов
(шаблон функции)

operator== operator<=>

(C++20)

сравнивает расстояния до конца
(шаблон функции)

operator+

(C++20)

перемещает итератор вперед
(шаблон функции)

operator-

(C++20)

вычисляет расстояние между двумя адаптерами итераторов
(шаблон функции)

operator== operator!=

(удалено в C++20)

сравнивает два


          istream_iterator

а
(шаблон функции)

operator== operator!=

(удалено в C++20)

сравнивает два


          istreambuf_iterator

а
(шаблон функции)

Операции

advance

перемещает итератор на заданное расстояние
(шаблон функции)

distance

возвращает расстояние между двумя итераторами
(шаблон функции)

(C++11)

увеличивает итератор
(шаблон функции)

(C++11)

уменьшает итератор
(шаблон функции)

ranges::advance

(C++20)

перемещает итератор на заданное расстояние или до указанной границы
(функциональный объект алгоритма)

ranges::distance

(C++20)

возвращает расстояние между итератором и стражем, или между началом и концом диапазона
(функциональный объект алгоритма)

ranges::next

(C++20)

увеличивает итератор на заданное расстояние или до границы
(функциональный объект алгоритма)

ranges::prev

(C++20)

уменьшает итератор на заданное расстояние или до границы
(функциональный объект алгоритма)

Доступ к диапазону

begin cbegin

(C++11) (C++14)

возвращает итератор на начало контейнера или массива
(шаблон функции)

end cend

(C++11) (C++14)

возвращает итератор на конец контейнера или массива
(шаблон функции)

rbegin crbegin

(C++14)

возвращает обратный итератор на начало контейнера или массива
(шаблон функции)

rend crend

(C++14)

возвращает обратный конечный итератор для контейнера или массива
(шаблон функции)

size ssize

(C++17) (C++20)

возвращает размер контейнера или массива
(шаблон функции)

empty

(C++17)

проверяет, является ли контейнер пустым
(шаблон функции)

data

(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 } -> /* может ссылаться */;  // не требуется сохранять равенство
    };
  // ассоциированные типы
  // инкрементируемые свойства
  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 = /* см. описание */;
  // характеристики итераторов
  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 {
    // точки кастомизации объектов
    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
(Примечание: В данном случае переводить нечего, так как текст состоит только из HTML-разметки и C++ термина `ranges::iter_move`, который согласно инструкции не подлежит переводу. Если бы был окружающий текст на английском, он был бы переведен на русский с сохранением всех HTML-тегов и исключением содержимого тегов , ,  $.)$ (t) } -> /* может-ссылаться */;
    }
  using iter_rvalue_reference_t
    = decltype(ranges::iter_move
(Примечание: В данном случае переводить нечего, так как текст состоит только из HTML-тегов и C++ термина `ranges::iter_move`, который согласно инструкции не подлежит переводу)(declval<T&>()));
  // концепции итераторов
  // концепция 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 = /* см. описание */;
  // требования к косвенно вызываемым объектам
  // косвенные вызываемые объекты
  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>...>;
  // проекция
  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>&>>;
  // общие требования к алгоритмам
  // концепция 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 = /* см. описание */;
  // концепция сортируемый
  template<class I, class R = ranges::less, class P = identity>
    concept sortable = /* см. описание */;
  // примитивы
  // итераторные теги
  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 { };
  // операции с итераторами
  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);
  // операции с итераторами диапазона
  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);
  }
  // предопределенные итераторы и сентинелы
  // обратные итераторы
  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.база() - 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;
  // итераторы вставки
  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);
  // перемещение итераторов и стражей
  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.база() - 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>>;
      };
}

**Примечание:** Весь код C++ внутри тегов `

` и `` оставлен без изменений, как и требовалось. HTML-теги и атрибуты также сохранены в оригинальном виде.

Концепт `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>>;
}

**Примечание:** Весь код C++ внутри тегов `

` и `` оставлен без изменений, как и требовалось в инструкциях. HTML-теги и атрибуты также сохранены в оригинальном виде.

Концепт `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>>;
}

**Примечание:** Весь код C++ внутри тегов `

` и `` оставлен без изменений, как и требовалось. HTML-разметка и атрибуты также сохранены в оригинальном виде.

Концепт `indirectly_copyable`

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

**Примечание:** Весь код C++ внутри тегов `

` и `` оставлен без изменений, как и требовалось. HTML-теги и атрибуты также сохранены в оригинале.

Концепт `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 { };
}

**Примечание:** Весь код C++ внутри тегов `

` и `` оставлен без изменений, как и требовалось. HTML-теги и атрибуты также сохранены в оригинальном виде.

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

**Примечание:** Весь код C++ внутри тегов `

` и `` оставлен без изменений, как и требовалось. HTML-теги и атрибуты также сохранены в оригинальном виде.

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

**Примечание:** Весь код C++ внутри тегов `

` и `` оставлен без изменений, как и требовалось. HTML-теги и атрибуты также сохранены в оригинальном виде.

Шаблон класса 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           = /* не указано */;
    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++ внутри тегов `

` и `` оставлен без изменений, как и требовалось. HTML-теги и атрибуты также сохранены в оригинальном виде.

Отчеты о дефектах

Следующие отчеты о дефектах, изменяющих поведение, были применены ретроактивно к ранее опубликованным стандартам C++.

DR	Применяется к	Поведение в опубликованной версии	Корректное поведение
LWG 349	C++98	закрытый член `delim` в std::ostream_iterator имел тип const char *	исправлено на const CharT *

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

cppreference.net

Namespaces

Variants

Standard library header <iterator>

Содержание

Концепции

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

Концепции косвенно вызываемых объектов

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

Классы

Утилиты алгоритмов

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

Примитивы

Адаптеры

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

Объекты точек кастомизации

Константы

Функции

Адаптеры

Нечленные операторы

Операции

Доступ к диапазону

Синопсис

Концепт 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

Шаблон класса std::incrementable_traits

Шаблон класса std::indirectly_readable_traits

Шаблон класса std::projected

Шаблон класса std::iterator_traits

Теги итераторов

Шаблон класса std::reverse_iterator

Шаблон класса std::back_insert_iterator

Шаблон класса std::front_insert_iterator

Шаблон класса std::insert_iterator

Шаблон класса std::move_iterator

Шаблон класса std::move_sentinel

Шаблон класса std::common_iterator

Класс std::default_sentinel_t

Шаблон класса std::counted_iterator

Класс std::unreachable_sentinel_t

Шаблон класса std::istream_iterator

Шаблон класса std::ostream_iterator

Шаблон класса std::istreambuf_iterator

Шаблон класса std::ostreambuf_iterator

Шаблон класса std::iterator

Отчеты о дефектах

Концепт `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`