Range-v3 Range algorithms, views, and actions for the Standard Library |

Modules | Classes | Typedefs | Functions | Variables
Iterator

## Description

Iterator functionality.

## Modules
| Iterator Concepts

## Classes
struct | ranges::advance_fn
struct | ranges::back_insert_iterator< Container >
struct | ranges::back_inserter_fn
struct | ranges::basic_iterator< Cur >
struct | ranges::basic_mixin< T >
struct | ranges::common_iterator< I, S >
struct | ranges::contiguous_iterator_tag
struct | ranges::default_sentinel_t
struct | ranges::distance_compare_fn
struct | ranges::distance_fn
struct | ranges::enumerate_fn
struct | ranges::front_insert_iterator< Container >
struct | ranges::front_inserter_fn
struct | ranges::get_cursor_fn
| Get a cursor from a basic_iterator. More...
struct | ranges::incrementable_traits< T >
struct | ranges::incrementable_traits< T const >
struct | ranges::indirectly_readable_traits< T >
struct | ranges::indirectly_readable_traits< common_iterator< I, S > >
struct | ranges::indirectly_readable_traits< T const >
struct | ranges::insert_iterator< Container >
struct | ranges::inserter_fn
struct | ranges::is_indirectly_movable< I, O >
struct | ranges::is_indirectly_swappable< T, U >
struct | ranges::is_nothrow_indirectly_movable< I, O >
struct | ranges::is_nothrow_indirectly_swappable< T, U >
struct | ranges::iter_distance_compare_fn
struct | ranges::iter_distance_fn
struct | ranges::iter_enumerate_fn
struct | ranges::iter_size_fn
struct | ranges::make_move_iterator_fn
struct | ranges::make_move_sentinel_fn
struct | ranges::make_ostream_joiner_fn
struct | ranges::make_reverse_iterator_fn
struct | ranges::move_into_fn
struct | ranges::move_iterator< I >
struct | ranges::move_sentinel< S >
struct | ranges::next_fn
struct | ranges::ostream_iterator< T, Char, Traits >
struct | ranges::ostream_joiner< Delim, Char, Traits >
struct | ranges::ostreambuf_iterator< Char, Traits >
struct | ranges::prev_fn
struct | ranges::unreachable_sentinel_t

## Typedefs
template<typename I >
using | ranges::iter_common_reference_t = common_reference_t< iter_reference_t< I >, iter_value_t< I > & >
template<typename T >
using | ranges::iter_difference_t = typename incrementable_traits< uncvref_t< T > >::difference_type
template<typename R >
using | ranges::iter_reference_t = detail::iter_reference_t_< R >
template<typename I >
using | ranges::iter_rvalue_reference_t = detail::iter_rvalue_reference_t< I >
template<typename R >
using | ranges::iter_value_t = detail::iter_value_t_< uncvref_t< R > >

## Functions
template<typename Cur , typename Cur2 >
constexpr bool | ranges::operator!= (basic_iterator< Cur > const &left, basic_iterator< Cur2 > const &right)
template<typename Cur , typename S >
constexpr bool | ranges::operator!= (basic_iterator< Cur > const &left, S const &right)
template<typename I1 , typename I2 , typename S1 , typename S2 >
bool | ranges::operator!= (common_iterator< I1, S1 > const &x, common_iterator< I2, S2 > const &y)
template<typename S , typename Cur >
constexpr bool | ranges::operator!= (S const &left, basic_iterator< Cur > const &right)
template<typename Cur >
constexpr basic_iterator< Cur > | ranges::operator+ (basic_iterator< Cur > left, typename basic_iterator< Cur >::difference_type n)
template<typename Cur >
constexpr basic_iterator< Cur > | ranges::operator+ (typename basic_iterator< Cur >::difference_type n, basic_iterator< Cur > right)
template<typename Cur , typename S >
constexpr basic_iterator< Cur >::difference_type | ranges::operator- (basic_iterator< Cur > const &left, S const &right)
template<typename Cur >
constexpr basic_iterator< Cur > | ranges::operator- (basic_iterator< Cur > left, typename basic_iterator< Cur >::difference_type n)
template<typename Cur2 , typename Cur >
constexpr basic_iterator< Cur >::difference_type | ranges::operator- (basic_iterator< Cur2 > const &left, basic_iterator< Cur > const &right)
template<typename I1 , typename I2 , typename S1 , typename S2 >
iter_difference_t< I2 > | ranges::operator- (common_iterator< I1, S1 > const &x, common_iterator< I2, S2 > const &y)
template<typename S , typename Cur >
constexpr basic_iterator< Cur >::difference_type | ranges::operator- (S const &left, basic_iterator< Cur > const &right)
template<typename Left , typename Right >
constexpr bool | ranges::operator< (basic_iterator< Left > const &left, basic_iterator< Right > const &right)
template<typename Left , typename Right >
constexpr bool | ranges::operator<= (basic_iterator< Left > const &left, basic_iterator< Right > const &right)
template<typename Cur , typename Cur2 >
constexpr bool | ranges::operator== (basic_iterator< Cur > const &left, basic_iterator< Cur2 > const &right)
template<typename Cur , typename S >
constexpr bool | ranges::operator== (basic_iterator< Cur > const &left, S const &right)
template<typename I1 , typename I2 , typename S1 , typename S2 >
bool | ranges::operator== (common_iterator< I1, S1 > const &x, common_iterator< I2, S2 > const &y)
template<typename S , typename Cur >
constexpr bool | ranges::operator== (S const &left, basic_iterator< Cur > const &right)
template<typename Left , typename Right >
constexpr bool | ranges::operator> (basic_iterator< Left > const &left, basic_iterator< Right > const &right)
template<typename Left , typename Right >
constexpr bool | ranges::operator>= (basic_iterator< Left > const &left, basic_iterator< Right > const &right)

## Variables
constexpr advance_fn | ranges::advance {}
constexpr back_inserter_fn | ranges::back_inserter {}
constexpr default_sentinel_t | ranges::default_sentinel {}
constexpr distance_fn | ranges::distance {}
constexpr distance_compare_fn | ranges::distance_compare {}
constexpr enumerate_fn | ranges::enumerate {}
constexpr front_inserter_fn | ranges::front_inserter {}
constexpr get_cursor_fn | ranges::get_cursor {}
constexpr inserter_fn | ranges::inserter {}
template<typename I , typename O >
constexpr bool | ranges::is_indirectly_movable_v
template<typename T , typename U >
constexpr bool | ranges::is_indirectly_swappable_v
template<typename I , typename O >
constexpr bool | ranges::is_nothrow_indirectly_movable_v
template<typename T , typename U >
constexpr bool | ranges::is_nothrow_indirectly_swappable_v
constexpr iter_distance_fn | ranges::iter_distance {}
constexpr iter_distance_compare_fn | ranges::iter_distance_compare {}
constexpr iter_enumerate_fn | ranges::iter_enumerate {}
constexpr _iter_move_::fn | ranges::iter_move {}
constexpr iter_size_fn | ranges::iter_size {}
constexpr _iter_swap_::fn | iter_swap {}
constexpr make_move_iterator_fn | ranges::make_move_iterator {}
constexpr make_move_sentinel_fn | ranges::make_move_sentinel {}
constexpr make_ostream_joiner_fn | ranges::make_ostream_joiner {}
constexpr make_reverse_iterator_fn | ranges::make_reverse_iterator {}
constexpr move_into_fn | ranges::move_into {}
constexpr next_fn | ranges::next {}
constexpr prev_fn | ranges::prev {}
constexpr adl_uncounted_recounted_detail::recounted_fn | ranges::recounted {}
constexpr adl_uncounted_recounted_detail::uncounted_fn | ranges::uncounted {}
constexpr unreachable_sentinel_t | ranges::unreachable {}

## Function Documentation

## ◆ operator!=() [1/4]

template<typename Cur , typename Cur2 >

constexpr bool ranges::operator!= | ( | basic_iterator< Cur > const & | left,
|  | basic_iterator< Cur2 > const & | right
| ) |  |
| constexpr

`#include <range/v3/iterator/basic_iterator.hpp>`

Precondition
  requires `detail::sentinel_for_cursor<Cur2, Cur>`

## ◆ operator!=() [2/4]

template<typename Cur , typename S >

constexpr bool ranges::operator!= | ( | basic_iterator< Cur > const & | left,
|  | S const & | right
| ) |  |
| constexpr

`#include <range/v3/iterator/basic_iterator.hpp>`

Precondition
  requires `detail::sentinel_for_cursor<S, Cur>`

## ◆ operator!=() [3/4]

template<typename I1 , typename I2 , typename S1 , typename S2 >

bool ranges::operator!= | ( | common_iterator< I1, S1 > const & | x,
|  | common_iterator< I2, S2 > const & | y
| ) |  |

`#include <range/v3/iterator/common_iterator.hpp>`

Precondition
  requires `sentinel_for<S1, I2> && sentinel_for<S2, I1>`

## ◆ operator!=() [4/4]

template<typename S , typename Cur >

constexpr bool ranges::operator!= | ( | S const & | left,
|  | basic_iterator< Cur > const & | right
| ) |  |
| constexpr

`#include <range/v3/iterator/basic_iterator.hpp>`

Precondition
  requires `detail::sentinel_for_cursor<S, Cur>`

## ◆ operator+() [1/2]

template<typename Cur >

constexpr basic_iterator<Cur> ranges::operator+ | ( | basic_iterator< Cur > | left,
|  | typename basic_iterator< Cur >::difference_type | n
| ) |  |
| constexpr

`#include <range/v3/iterator/basic_iterator.hpp>`

Precondition
  requires `detail::random_access_cursor<Cur>`

## ◆ operator+() [2/2]

template<typename Cur >

constexpr basic_iterator<Cur> ranges::operator+ | ( | typename basic_iterator< Cur >::difference_type | n,
|  | basic_iterator< Cur > | right
| ) |  |
| constexpr

`#include <range/v3/iterator/basic_iterator.hpp>`

Precondition
  requires `detail::random_access_cursor<Cur>`

## ◆ operator-() [1/5]

template<typename Cur , typename S >

constexpr basic_iterator<Cur>::difference_type ranges::operator- | ( | basic_iterator< Cur > const & | left,
|  | S const & | right
| ) |  |
| constexpr

`#include <range/v3/iterator/basic_iterator.hpp>`

Precondition
  requires `detail::sized_sentinel_for_cursor<S, Cur>`

## ◆ operator-() [2/5]

template<typename Cur >

constexpr basic_iterator<Cur> ranges::operator- | ( | basic_iterator< Cur > | left,
|  | typename basic_iterator< Cur >::difference_type | n
| ) |  |
| constexpr

`#include <range/v3/iterator/basic_iterator.hpp>`

Precondition
  requires `detail::random_access_cursor<Cur>`

## ◆ operator-() [3/5]

template<typename Cur2 , typename Cur >

constexpr basic_iterator<Cur>::difference_type ranges::operator- | ( | basic_iterator< Cur2 > const & | left,
|  | basic_iterator< Cur > const & | right
| ) |  |
| constexpr

`#include <range/v3/iterator/basic_iterator.hpp>`

Precondition
  requires `detail::sized_sentinel_for_cursor<Cur2, Cur>`

## ◆ operator-() [4/5]

template<typename I1 , typename I2 , typename S1 , typename S2 >

iter_difference_t<I2> ranges::operator- | ( | common_iterator< I1, S1 > const & | x,
|  | common_iterator< I2, S2 > const & | y
| ) |  |

`#include <range/v3/iterator/common_iterator.hpp>`

Precondition
  requires `sized_sentinel_for<I1, I2> && sized_sentinel_for<S1, I2> && sized_sentinel_for<S2, I1>`

## ◆ operator-() [5/5]

template<typename S , typename Cur >

constexpr basic_iterator<Cur>::difference_type ranges::operator- | ( | S const & | left,
|  | basic_iterator< Cur > const & | right
| ) |  |
| constexpr

`#include <range/v3/iterator/basic_iterator.hpp>`

Precondition
  requires `detail::sized_sentinel_for_cursor<S, Cur>`

## ◆ operator<()

template<typename Left , typename Right >

constexpr bool ranges::operator< | ( | basic_iterator< Left > const & | left,
|  | basic_iterator< Right > const & | right
| ) |  |
| constexpr

`#include <range/v3/iterator/basic_iterator.hpp>`

Precondition
  requires `detail::sized_sentinel_for_cursor<Right, Left>`

## ◆ operator<=()

template<typename Left , typename Right >

constexpr bool ranges::operator<= | ( | basic_iterator< Left > const & | left,
|  | basic_iterator< Right > const & | right
| ) |  |
| constexpr

`#include <range/v3/iterator/basic_iterator.hpp>`

Precondition
  requires `detail::sized_sentinel_for_cursor<Right, Left>`

## ◆ operator==() [1/4]

template<typename Cur , typename Cur2 >

constexpr bool ranges::operator== | ( | basic_iterator< Cur > const & | left,
|  | basic_iterator< Cur2 > const & | right
| ) |  |
| constexpr

`#include <range/v3/iterator/basic_iterator.hpp>`

Precondition
  requires `detail::sentinel_for_cursor<Cur2, Cur>`

## ◆ operator==() [2/4]

template<typename Cur , typename S >

constexpr bool ranges::operator== | ( | basic_iterator< Cur > const & | left,
|  | S const & | right
| ) |  |
| constexpr

`#include <range/v3/iterator/basic_iterator.hpp>`

Precondition
  requires `detail::sentinel_for_cursor<S, Cur>`

## ◆ operator==() [3/4]

template<typename I1 , typename I2 , typename S1 , typename S2 >

bool ranges::operator== | ( | common_iterator< I1, S1 > const & | x,
|  | common_iterator< I2, S2 > const & | y
| ) |  |

`#include <range/v3/iterator/common_iterator.hpp>`

Precondition
  requires `sentinel_for<S1, I2> && sentinel_for<S2, I1> && (!equality_comparable_with<I1, I2>)` //
  requires `sentinel_for<S1, I2> && sentinel_for<S2, I1> && equality_comparable_with<I1, I2>`

## ◆ operator==() [4/4]

template<typename S , typename Cur >

constexpr bool ranges::operator== | ( | S const & | left,
|  | basic_iterator< Cur > const & | right
| ) |  |
| constexpr

`#include <range/v3/iterator/basic_iterator.hpp>`

Precondition
  requires `detail::sentinel_for_cursor<S, Cur>`

## ◆ operator>()

template<typename Left , typename Right >

constexpr bool ranges::operator> | ( | basic_iterator< Left > const & | left,
|  | basic_iterator< Right > const & | right
| ) |  |
| constexpr

`#include <range/v3/iterator/basic_iterator.hpp>`

Precondition
  requires `detail::sized_sentinel_for_cursor<Right, Left>`

## ◆ operator>=()

template<typename Left , typename Right >

constexpr bool ranges::operator>= | ( | basic_iterator< Left > const & | left,
|  | basic_iterator< Right > const & | right
| ) |  |
| constexpr

`#include <range/v3/iterator/basic_iterator.hpp>`

Precondition
  requires `detail::sized_sentinel_for_cursor<Right, Left>`

## Variable Documentation

## ◆ advance

constexpr advance_fn ranges::advance {}
| constexpr

`#include <range/v3/iterator/operations.hpp>`

See also
  `advance_fn`

## ◆ back_inserter

constexpr back_inserter_fn ranges::back_inserter {}
| constexpr

`#include <range/v3/iterator/insert_iterators.hpp>`

See also
  `back_inserter_fn`

## ◆ distance

constexpr distance_fn ranges::distance {}
| constexpr

`#include <range/v3/iterator/operations.hpp>`

See also
  `distance_fn`

Referenced by ranges::ends_with(), and ranges::sample().

## ◆ distance_compare

constexpr distance_compare_fn ranges::distance_compare {}
| constexpr

`#include <range/v3/iterator/operations.hpp>`

See also
  `distance_compare_fn`

## ◆ enumerate

constexpr enumerate_fn ranges::enumerate {}
| related

`#include <range/v3/iterator/operations.hpp>`

See also
  `enumerate_fn`

## ◆ front_inserter

constexpr front_inserter_fn ranges::front_inserter {}
| constexpr

`#include <range/v3/iterator/insert_iterators.hpp>`

See also
  `front_inserter_fn`

## ◆ get_cursor

constexpr get_cursor_fn ranges::get_cursor {}
| constexpr

`#include <range/v3/iterator/basic_iterator.hpp>`

See also
  `get_cursor_fn`

## ◆ inserter

constexpr inserter_fn ranges::inserter {}
| constexpr

`#include <range/v3/iterator/insert_iterators.hpp>`

See also
  `inserter_fn`

## ◆ is_indirectly_movable_v

template<typename I , typename O >

constexpr bool ranges::is_indirectly_movable_v
| constexpr

`#include <range/v3/iterator/access.hpp>`

Initial value:
=
decltype(detail::is_indirectly_movable_<I, O>(nullptr, nullptr))::value

## ◆ is_indirectly_swappable_v

template<typename T , typename U >

constexpr bool ranges::is_indirectly_swappable_v
| constexpr

`#include <range/v3/iterator/access.hpp>`

Initial value:
=
decltype(detail::is_indirectly_swappable_<T, U>(nullptr, nullptr))::value

## ◆ is_nothrow_indirectly_movable_v

template<typename I , typename O >

constexpr bool ranges::is_nothrow_indirectly_movable_v
| constexpr

`#include <range/v3/iterator/access.hpp>`

Initial value:
=
decltype(detail::is_nothrow_indirectly_movable_<I, O>(nullptr))::value

## ◆ is_nothrow_indirectly_swappable_v

template<typename T , typename U >

constexpr bool ranges::is_nothrow_indirectly_swappable_v
| constexpr

`#include <range/v3/iterator/access.hpp>`

Initial value:
=
decltype(detail::is_nothrow_indirectly_swappable_<T, U>(0))::value

## ◆ iter_distance

constexpr iter_distance_fn ranges::iter_distance {}
| constexpr

`#include <range/v3/iterator/operations.hpp>`

See also
  `iter_distance_fn`

## ◆ iter_distance_compare

constexpr iter_distance_compare_fn ranges::iter_distance_compare {}
| constexpr

`#include <range/v3/iterator/operations.hpp>`

See also
  `iter_distance_compare_fn`

## ◆ iter_enumerate

constexpr iter_enumerate_fn ranges::iter_enumerate {}
| constexpr

`#include <range/v3/iterator/operations.hpp>`

See also
  `iter_enumerate_fn`

## ◆ iter_size

constexpr iter_size_fn ranges::iter_size {}
| constexpr

`#include <range/v3/iterator/operations.hpp>`

See also
  `iter_size_fn`

## ◆ iter_swap

constexpr _iter_swap_::fn iter_swap {}
| constexpr

`#include <range/v3/iterator/access.hpp>`

>iter_swap::fn

Referenced by ranges::next_permutation(), ranges::partial_sort(), and ranges::prev_permutation().

## ◆ make_ostream_joiner

constexpr make_ostream_joiner_fn ranges::make_ostream_joiner {}
| constexpr

`#include <range/v3/iterator/stream_iterators.hpp>`

See also
  `make_ostream_joiner_fn`

## ◆ move_into

constexpr move_into_fn ranges::move_into {}
| constexpr

`#include <range/v3/iterator/move_iterators.hpp>`

See also
  `move_into_fn`

## ◆ next

constexpr next_fn ranges::next {}
| constexpr

`#include <range/v3/iterator/operations.hpp>`

See also
  `next_fn`

Referenced by ranges::ends_with(), ranges::is_permutation(), and ranges::sort().

## ◆ prev

constexpr prev_fn ranges::prev {}
| constexpr

`#include <range/v3/iterator/operations.hpp>`

See also
  `prev_fn`