Experimental library header <experimental/ranges/iterator>

From cppreference.net

<experimental/execution>

Filesystem TS

<experimental/filesystem>

Parallelism TS (v1, v2)

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

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

Library Fundamentals TS (v1, v2, v3)

`experimental/algorithm`
`<experimental/any>`
`experimental/array`
`experimental/chrono`
`experimental/deque`
`experimental/forward_list`
`<experimental/functional>`
`experimental/future`
`experimental/iterator`
`experimental/list`
`experimental/map`
`experimental/memory`
`<experimental/memory_resource>`
`experimental/numeric`
`<experimental/optional>`
`experimental/propagate_const`

`experimental/random`
`experimental/ratio`
`experimental/regex`
`experimental/scope`
`experimental/set`
`experimental/source_location`
`experimental/string`
`<experimental/string_view>`
`experimental/system_error`
`experimental/tuple`
`experimental/type_traits`
`experimental/unordered_map`
`experimental/unordered_set`
`experimental/utility`
`experimental/vector`

Concurrency TS

`experimental/atomic`
`experimental/barrier`

`experimental/future`
`experimental/latch`

Ranges TS

`<experimental/ranges/algorithm>`
`<experimental/ranges/concepts>`
`<experimental/ranges/functional>`
`<experimental/ranges/iterator>`

`<experimental/ranges/random>`
`<experimental/ranges/tuple>`
`<experimental/ranges/type_traits>`
`<experimental/ranges/utility>`

Coroutines TS


               experimental/coroutine

Networking TS

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

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

Reflection TS

<experimental/reflect>

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

Содержание

Концепции, связанные с итераторами

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


           std::experimental::ranges

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

Readable	определяет, что тип является читаемым путем применения оператора `*` (концепт)
Writable	определяет, что значение может быть записано в объект, на который ссылается итератор (концепт)
WeaklyIncrementable	определяет, что `Semiregular` тип может быть инкрементирован с помощью пре- и постинкрементных операторов (концепт)
Incrementable	определяет, что операция инкремента для `WeaklyIncrementable` типа сохраняет равенство и что тип является `EqualityComparable` (концепт)
Iterator	определяет, что объекты типа могут быть инкрементированы и разыменованы (концепт)
Sentinel	определяет, что объекты типа являются стражем для типа `Iterator` (концепт)
SizedSentinel	определяет, что оператор `-` может быть применен к итератору и стражу для вычисления их разницы за постоянное время (концепт)
InputIterator	определяет, что тип является входным итератором, то есть его значения могут быть прочитаны и он может быть как пре-, так и постинкрементирован (концепт)
OutputIterator	определяет, что тип является выходным итератором для заданного типа значения, то есть значения этого типа могут быть записаны в него и он может быть как пре-, так и постинкрементирован (концепт)
ForwardIterator	определяет, что `InputIterator` является однонаправленным итератором, поддерживающим сравнение на равенство и многопроходность (концепт)
BidirectionalIterator	определяет, что `ForwardIterator` является двунаправленным итератором, поддерживающим движение назад (концепт)
RandomAccessIterator	определяет, что `BidirectionalIterator` является итератором произвольного доступа, поддерживающим продвижение за постоянное время и индексацию (концепт)

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

IndirectUnaryInvocable IndirectRegularUnaryInvocable	определяет, что вызываемый тип может быть вызван с результатом разыменования `Readable` типа (концепт)
IndirectUnaryPredicate	определяет, что вызываемый объект при вызове с результатом разыменования `Readable` типа удовлетворяет `Predicate` (концепт)
IndirectRelation	определяет, что вызываемый объект при вызове с результатом разыменования некоторых `Readable` типов удовлетворяет `Relation` (концепт)
IndirectStrictWeakOrder	определяет, что вызываемый объект при вызове с результатом разыменования некоторых `Readable` типов удовлетворяет `StrictWeakOrder` (концепт)

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

IndirectlyMovable	определяет, что значения могут быть перемещены из `Readable` типа в `Writable` тип (концепт)
IndirectlyMovableStorable	определяет, что значения могут быть перемещены из `Readable` типа в `Writable` тип и что перемещение может быть выполнено через промежуточный объект (концепт)
IndirectlyCopyable	определяет, что значения могут быть скопированы из `Readable` типа в `Writable` тип (концепт)
IndirectlyCopyableStorable	определяет, что значения могут быть скопированы из `Readable` типа в `Writable` тип и что копирование может быть выполнено через промежуточный объект (концепт)
IndirectlySwappable	определяет, что значения, ссылаемые двумя `Readable` типами, могут быть обменены (концепт)
IndirectlyComparable	определяет, что значения, ссылаемые двумя `Readable` типами, могут быть сравнены (концепт)
Permutable	определяет общие требования алгоритмов, которые переупорядочивают элементы на месте (концепт)
Mergeable	определяет требования алгоритмов, которые объединяют отсортированные последовательности в выходную последовательность путем копирования элементов (концепт)
Sortable	определяет общие требования алгоритмов, которые переставляют последовательности в упорядоченные последовательности (концепт)

Утилиты концепций

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

Примитивы итераторов

Утилиты для итераторов

Определено в пространстве имен `std::experimental::ranges`
iter_move	преобразует результат разыменования объекта в связанный тип rvalue-ссылки (объект точки кастомизации)
iter_swap	обменивает значения, на которые ссылаются два разыменовываемых объекта (объект точки кастомизации)

Характеристики итераторов

Определено в пространстве имен `std::experimental::ranges`
difference_type	получает тип разности для `WeaklyIncrementable` типа (шаблон класса)
value_type	получает тип значения для `Readable` типа (шаблон класса)
iterator_category	получает категорию итератора для типа входного итератора (шаблон класса)
iterator_traits	совместимый класс характеристик, собирающий связанные типы итератора (шаблон псевдонима)
reference_t rvalue_reference_t iter_common_reference_t	получает связанные типы ссылок для разыменовываемого объекта (шаблон псевдонима)

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

Определено в пространстве имен `std::experimental::ranges`
input_iterator_tag output_iterator_tag forward_iterator_tag bidirectional_iterator_tag random_access_iterator_tag	пустые классы, используемые для указания категорий итераторов (класс)

std::iterator_traits специализации

Определено в пространстве имен `std`
std::iterator_traits <InputIterator> std::iterator_traits <OutputIterator>	специализирует std::iterator_traits для итераторов Ranges TS (специализация шаблона класса)

Операции с итераторами

Определено в пространстве имен `std::experimental::ranges`
advance	перемещает итератор на заданное расстояние (шаблон функции)
distance	возвращает расстояние между итератором и ограничителем, или между началом и концом диапазона (шаблон функции)
next	инкрементирует итератор (шаблон функции)
prev	декрементирует итератор (шаблон функции)

Адаптеры итераторов

Определено в пространстве имён `std::experimental::ranges`
reverse_iterator	адаптер итератора для обхода в обратном порядке (шаблон класса)
back_insert_iterator	адаптер итератора для вставки в конец контейнера (шаблон класса)
front_insert_iterator	адаптер итератора для вставки в начало контейнера (шаблон класса)
insert_iterator	адаптер итератора для вставки в контейнер (шаблон класса)
move_iterator	адаптер итератора, который разыменовывается в rvalue-ссылку (шаблон класса)
move_sentinel	адаптер стражника для использования с `move_iterator` (шаблон класса)
common_iterator	адаптирует пару итератор-стражник в общий тип итератора для использования с унаследованными алгоритмами (шаблон класса)
counted_iterator	адаптер итератора, который отслеживает расстояние от своей начальной позиции (шаблон класса)
default_sentinel	пустой тип стражника для использования с типами итераторов, которые знают границу своего диапазона (класс)
dangling	обёртка для возможно висячего итератора (шаблон класса)
safe_iterator_t	псевдоним шаблона, который оборачивает тип итератора rvalue-диапазона с помощью `dangling` (псевдоним шаблона)
unreachable	тип стражника, используемый с любым итератором для обозначения бесконечного диапазона (класс)

Потоковые итераторы

Определено в пространстве имен `std::experimental::ranges`
istream_iterator	входной итератор, который читает из std::basic_istream (шаблон класса)
ostream_iterator	выходной итератор, который записывает в std::basic_ostream (шаблон класса)
istreambuf_iterator	входной итератор, который читает из std::basic_streambuf (шаблон класса)
ostreambuf_iterator	выходной итератор, который записывает в std::basic_streambuf (шаблон класса)

Синопсис

namespace std { namespace experimental { namespace ranges { inline namespace v1 {
template <class T> concept bool /* разыменовываемый */ // только для демонстрации
  = requires(T& t) { {*t} -> auto&&; };
namespace {
  constexpr /* не указано */ iter_move = /* не указано */;
  constexpr /* не указано */ iter_swap = /* не указано */;
}
template <class> struct difference_type;
template <class T> using difference_type_t
  = typename difference_type<T>::type;
template <class> struct value_type;
template <class T> using value_type_t
  = typename value_type<T>::type;
template <class> struct iterator_category;
template <class T> using iterator_category_t
  = typename iterator_category<T>::type;
template </* разыменовываемый */ T> using reference_t
  = decltype(*declval<T&>());
template </* разыменовываемый */ T>
    requires /* см. определение */ using rvalue_reference_t
  = decltype(ranges::iter_move(declval<T&>()));
template <class In>
concept bool Readable = /* см. определение */;
template <class Out, class T>
concept bool Writable = /* см. определение */;
template <class I>
concept bool WeaklyIncrementable = /* см. определение */;
template <class I>
concept bool Incrementable = /* см. определение */;
template <class I>
concept bool Iterator = /* см. определение */;
template <class S, class I>
concept bool Sentinel = /* см. определение */;
template <class S, class I>
  constexpr bool disable_sized_sentinel = false;
template <class S, class I>
concept bool SizedSentinel = /* см. определение */;
template <class I>
concept bool InputIterator = /* см. определение */;
template <class I>
concept bool OutputIterator = /* см. определение */;
template <class I>
concept bool ForwardIterator = /* см. определение */;
template <class I>
concept bool BidirectionalIterator = /* см. определение */;
template <class I>
concept bool RandomAccessIterator = /* см. определение */;
template <class F, class I>
concept bool IndirectUnaryInvocable = /* см. определение */;
template <class F, class I>
concept bool IndirectRegularUnaryInvocable = /* см. определение */;
template <class F, class I>
concept bool IndirectUnaryPredicate = /* см. определение */;
template <class F, class I1, class I2 = I1>
concept bool IndirectRelation = /* см. определение */;
template <class F, class I1, class I2 = I1>
concept bool IndirectStrictWeakOrder = /* см. определение */;
template <class> struct indirect_result_of;
template <class F, class... Is>
  requires Invocable<F, reference_t<Is>...>
struct indirect_result_of<F(Is...)>;
template <class F>
using indirect_result_of_t
  = typename indirect_result_of<F>::type;
template <Readable I, IndirectRegularUnaryInvocable<I> Proj>
struct projected;
template <WeaklyIncrementable I, class Proj>
struct difference_type<projected<I, Proj>>;
template <class In, class Out>
concept bool IndirectlyMovable = /* см. определение */;
template <class In, class Out>
concept bool IndirectlyMovableStorable = /* см. определение */;
template <class In, class Out>
concept bool IndirectlyCopyable = /* см. определение */;
template <class In, class Out>
concept bool IndirectlyCopyableStorable = /* см. определение */;
template <class I1, class I2 = I1>
concept bool IndirectlySwappable = /* см. определение */;
template <class I1, class I2, class R = equal_to<>, class P1 = identity,
    class P2 = identity>
concept bool IndirectlyComparable = /* см. определение */;
template <class I>
concept bool Permutable = /* см. определение */;
template <class I1, class I2, class Out,
    class R = less<>, class P1 = identity, class P2 = identity>
concept bool Mergeable = /* см. определение */;
template <class I, class R = less<>, class P = identity>
concept bool Sortable = /* см. определение */;
template <class Iterator> using iterator_traits = /* см. определение */;
template <Readable T> using iter_common_reference_t
  = common_reference_t<reference_t<T>, value_type_t<T>&>;
struct output_iterator_tag { };
struct input_iterator_tag { };
struct forward_iterator_tag : input_iterator_tag { };
struct bidirectional_iterator_tag : forward_iterator_tag { };
struct random_access_iterator_tag : bidirectional_iterator_tag { };
namespace {
  constexpr /* не указано */ advance = /* не указано */;
  constexpr /* не указано */ distance = /* не указано */;
  constexpr /* не указано */ next = /* не указано */;
  constexpr /* не указано */ prev = /* не указано */;
}
template <BidirectionalIterator I> class reverse_iterator;
template <class I1, class I2>
    requires EqualityComparableWith<I1, I2>
  constexpr bool operator==(
    const reverse_iterator<I1>& x,
    const reverse_iterator<I2>& y);
template <class I1, class I2>
    requires EqualityComparableWith<I1, I2>
  constexpr bool operator!=(
    const reverse_iterator<I1>& x,
    const reverse_iterator<I2>& y);
template <class I1, class I2>
    requires StrictTotallyOrderedWith<I1, I2>
  constexpr bool operator<(
    const reverse_iterator<I1>& x,
    const reverse_iterator<I2>& y);
template <class I1, class I2>
    requires StrictTotallyOrderedWith<I1, I2>
  constexpr bool operator>(
    const reverse_iterator<I1>& x,
    const reverse_iterator<I2>& y);
template <class I1, class I2>
    requires StrictTotallyOrderedWith<I1, I2>
  constexpr bool operator>=(
    const reverse_iterator<I1>& x,
    const reverse_iterator<I2>& y);
template <class I1, class I2>
    requires StrictTotallyOrderedWith<I1, I2>
  constexpr bool operator<=(
    const reverse_iterator<I1>& x,
    const reverse_iterator<I2>& y);
template <class I1, class I2>
    requires SizedSentinel<I1, I2>
  constexpr difference_type_t<I2> operator-(
    const reverse_iterator<I1>& x,
    const reverse_iterator<I2>& y);
template <RandomAccessIterator I>
  constexpr reverse_iterator<I> operator+(
    difference_type_t<I> n,
    const reverse_iterator<I>& x);
template <BidirectionalIterator I>
constexpr reverse_iterator<I> make_reverse_iterator(I i);
template <class Container> class back_insert_iterator;
template <class Container>
  back_insert_iterator<Container> back_inserter(Container& x);
template <class Container> class front_insert_iterator;
template <class Container>
  front_insert_iterator<Container> front_inserter(Container& x);
template <class Container> class insert_iterator;
template <class Container>
  insert_iterator<Container> inserter(Container& x, iterator_t<Container> i);
template <InputIterator I> class move_iterator;
template <class I1, class I2>
    requires EqualityComparableWith<I1, I2>
  constexpr bool operator==(
    const move_iterator<I1>& x, const move_iterator<I2>& y);
template <class I1, class I2>
    requires EqualityComparableWith<I1, I2>
  constexpr bool operator!=(
    const move_iterator<I1>& x, const move_iterator<I2>& y);
template <class I1, class I2>
    requires StrictTotallyOrderedWith<I1, I2>
  constexpr bool operator<(
    const move_iterator<I1>& x, const move_iterator<I2>& y);
template <class I1, class I2>
    requires StrictTotallyOrderedWith<I1, I2>
  constexpr bool operator<=(
    const move_iterator<I1>& x, const move_iterator<I2>& y);
template <class I1, class I2>
    requires StrictTotallyOrderedWith<I1, I2>
  constexpr bool operator>(
    const move_iterator<I1>& x, const move_iterator<I2>& y);
template <class I1, class I2>
    requires StrictTotallyOrderedWith<I1, I2>
  constexpr bool operator>=(
    const move_iterator<I1>& x, const move_iterator<I2>& y);
template <class I1, class I2>
    requires SizedSentinel<I1, I2>
  constexpr difference_type_t<I2> operator-(
    const move_iterator<I1>& x,
    const move_iterator<I2>& y);
template <RandomAccessIterator I>
  constexpr move_iterator<I> operator+(
    difference_type_t<I> n,
    const move_iterator<I>& x);
template <InputIterator I>
  constexpr move_iterator<I> make_move_iterator(I i);
template <Semiregular S> class move_sentinel;
template <class I, Sentinel<I> S>
  constexpr bool operator==(
    const move_iterator<I>& i, const move_sentinel<S>& s);
template <class I, Sentinel<I> S>
  constexpr bool operator==(
    const move_sentinel<S>& s, const move_iterator<I>& i);
template <class I, Sentinel<I> S>
  constexpr bool operator!=(
    const move_iterator<I>& i, const move_sentinel<S>& s);
template <class I, Sentinel<I> S>
  constexpr bool operator!=(
    const move_sentinel<S>& s, const move_iterator<I>& i);
template <class I, SizedSentinel<I> S>
  constexpr difference_type_t<I> operator-(
    const move_sentinel<S>& s, const move_iterator<I>& i);
template <class I, SizedSentinel<I> S>
  constexpr difference_type_t<I> operator-(
    const move_iterator<I>& i, const move_sentinel<S>& s);
template <Semiregular S>
  constexpr move_sentinel<S> make_move_sentinel(S s);
template <Iterator I, Sentinel<I> S>
  requires !Same<I, S>
class common_iterator;
template <Readable I, class S>
struct value_type<common_iterator<I, S>>;
template <InputIterator I, class S>
struct iterator_category<common_iterator<I, S>>;
template <ForwardIterator I, class S>
struct iterator_category<common_iterator<I, S>>;
template <class I1, class I2, Sentinel<I2> S1, Sentinel<I1> S2>
bool operator==(
  const common_iterator<I1, S1>& x, const common_iterator<I2, S2>& y);
template <class I1, class I2, Sentinel<I2> S1, Sentinel<I1> S2>
  requires EqualityComparableWith<I1, I2>
bool operator==(
  const common_iterator<I1, S1>& x, const common_iterator<I2, S2>& y);
template <class I1, class I2, Sentinel<I2> S1, Sentinel<I1> S2>
bool operator!=(
  const common_iterator<I1, S1>& x, const common_iterator<I2, S2>& y);
template <class I2, SizedSentinel<I2> I1, SizedSentinel<I2> S1, SizedSentinel<I1> S2>
difference_type_t<I2> operator-(
  const common_iterator<I1, S1>& x, const common_iterator<I2, S2>& y);
class default_sentinel;
template <Iterator I> class counted_iterator;
template <class I1, class I2>
    requires Common<I1, I2>
  constexpr bool operator==(
    const counted_iterator<I1>& x, const counted_iterator<I2>& y);
constexpr bool operator==(
  const counted_iterator<auto>& x, default_sentinel);
constexpr bool operator==(
  default_sentinel, const counted_iterator<auto>& x);
template <class I1, class I2>
    requires Common<I1, I2>
  constexpr bool operator!=(
    const counted_iterator<I1>& x, const counted_iterator<I2>& y);
constexpr bool operator!=(
  const counted_iterator<auto>& x, default_sentinel y);
constexpr bool operator!=(
  default_sentinel x, const counted_iterator<auto>& y);
template <class I1, class I2>
    requires Common<I1, I2>
  constexpr bool operator<(
    const counted_iterator<I1>& x, const counted_iterator<I2>& y);
template <class I1, class I2>
    requires Common<I1, I2>
  constexpr bool operator<=(
    const counted_iterator<I1>& x, const counted_iterator<I2>& y);
template <class I1, class I2>
    requires Common<I1, I2>
  constexpr bool operator>(
    const counted_iterator<I1>& x, const counted_iterator<I2>& y);
template <class I1, class I2>
    requires Common<I1, I2>
  constexpr bool operator>=(
    const counted_iterator<I1>& x, const counted_iterator<I2>& y);
template <class I1, class I2>
    requires Common<I1, I2>
  constexpr difference_type_t<I2> operator-(
    const counted_iterator<I1>& x, const counted_iterator<I2>& y);
template <class I>
  constexpr difference_type_t<I> operator-(
    const counted_iterator<I>& x, default_sentinel y);
template <class I>
  constexpr difference_type_t<I> operator-(
    default_sentinel x, const counted_iterator<I>& y);
template <RandomAccessIterator I>
  constexpr counted_iterator<I>
    operator+(difference_type_t<I> n, const counted_iterator<I>& x);
template <Iterator I>
  constexpr counted_iterator<I> make_counted_iterator(I i, difference_type_t<I> n);
class unreachable;
template <Iterator I>
  constexpr bool operator==(const I&, unreachable) noexcept;
template <Iterator I>
  constexpr bool operator==(unreachable, const I&) noexcept;
template <Iterator I>
  constexpr bool operator!=(const I&, unreachable) noexcept;
template <Iterator I>
  constexpr bool operator!=(unreachable, const I&) noexcept;
template <class T> class dangling;
template <class T, class CharT = char, class Traits = char_traits<CharT>,
    class Distance = ptrdiff_t>
  class istream_iterator;
template <class T, class CharT, class Traits, class Distance>
  bool operator==(const istream_iterator<T, CharT, Traits, Distance>& x,
    const istream_iterator<T, CharT, Traits, Distance>& y);
template <class T, class CharT, class Traits, class Distance>
  bool operator==(default_sentinel x,
    const istream_iterator<T, CharT, Traits, Distance>& y);
template <class T, class CharT, class Traits, class Distance>
  bool operator==(const istream_iterator<T, CharT, Traits, Distance>& x,
    default_sentinel y);
template <class T, class CharT, class Traits, class Distance>
  bool operator!=(const istream_iterator<T, CharT, Traits, Distance>& x,
    const istream_iterator<T, CharT, Traits, Distance>& y);
template <class T, class CharT, class Traits, class Distance>
  bool operator!=(default_sentinel x,
    const istream_iterator<T, CharT, Traits, Distance>& y);
template <class T, class CharT, class Traits, class Distance>
  bool operator!=(const istream_iterator<T, CharT, Traits, Distance>& x,
    default_sentinel y);
template <class T, class CharT = char, class Traits = char_traits<CharT>>
  class ostream_iterator;
template <class CharT, class Traits = char_traits<CharT> >
  class istreambuf_iterator;
template <class CharT, class Traits>
  bool operator==(const istreambuf_iterator<CharT, Traits>& a,
    const istreambuf_iterator<CharT, Traits>& b);
template <class CharT, class Traits>
  bool operator==(default_sentinel a,
    const istreambuf_iterator<CharT, Traits>& b);
template <class CharT, class Traits>
  bool operator==(const istreambuf_iterator<CharT, Traits>& a,
    default_sentinel b);
template <class CharT, class Traits>
  bool operator!=(const istreambuf_iterator<CharT, Traits>& a,
    const istreambuf_iterator<CharT, Traits>& b);
template <class CharT, class Traits>
  bool operator!=(default_sentinel a,
    const istreambuf_iterator<CharT, Traits>& b);
template <class CharT, class Traits>
  bool operator!=(const istreambuf_iterator<CharT, Traits>& a,
    default_sentinel b);
template <class CharT, class Traits = char_traits<CharT> >
  class ostreambuf_iterator;
}}}}
namespace std {
  template <experimental::ranges::Итератор Out>
    struct iterator_traits<Out>;
  template <experimental::ranges::InputIterator In>
    struct iterator_traits<In>;
  template <experimental::ranges::InputIterator In>
      requires experimental::ranges::Сентинел<In, In>
    struct iterator_traits;
}

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

cppreference.net

Namespaces

Variants