cpp/header/experimental/ranges/iterator

This header is part of the ranges library.

Synopsis
{{source|1=

namespace std { namespace experimental { namespace ranges { inline namespace v1 {

template  concept bool /* dereferenceable */ // exposition only = requires(T& t) { {*t} -> auto&&; };

namespace { constexpr /* unspecified */ iter_move = /* unspecified */; constexpr /* unspecified */ iter_swap = /* unspecified */; }

template struct difference_type; template  using difference_type_t = typename difference_type::type;

template struct value_type; template  using value_type_t = typename value_type::type;

template struct iterator_category; template  using iterator_category_t = typename iterator_category::type;

template  using reference_t = decltype(*declval);

template    requires /* see definition */ using rvalue_reference_t = decltype(ranges::iter_move(declval));

template  concept bool Readable = /* see definition */;

template  concept bool Writable = /* see definition */;

template  concept bool WeaklyIncrementable = /* see definition */;

template  concept bool Incrementable = /* see definition */;

template  concept bool Iterator = /* see definition */;

template <class S, class I> concept bool Sentinel = /* see definition */;

template <class S, class I> constexpr bool disable_sized_sentinel = false;

template <class S, class I> concept bool SizedSentinel = /* see definition */;

template <class I> concept bool InputIterator = /* see definition */;

template <class I> concept bool OutputIterator = /* see definition */;

template <class I> concept bool ForwardIterator = /* see definition */;

template <class I> concept bool BidirectionalIterator = /* see definition */;

template <class I> concept bool RandomAccessIterator = /* see definition */;

template <class F, class I> concept bool IndirectUnaryInvocable = /* see definition */;

template <class F, class I> concept bool IndirectRegularUnaryInvocable = /* see definition */;

template <class F, class I> concept bool IndirectUnaryPredicate = /* see definition */;

template <class F, class I1, class I2 = I1> concept bool IndirectRelation = /* see definition */;

template <class F, class I1, class I2 = I1> concept bool IndirectStrictWeakOrder = /* see definition */;

template 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 = /* see definition */;

template <class In, class Out> concept bool IndirectlyMovableStorable = /* see definition */;

template <class In, class Out> concept bool IndirectlyCopyable = /* see definition */;

template <class In, class Out> concept bool IndirectlyCopyableStorable = /* see definition */;

template <class I1, class I2 = I1> concept bool IndirectlySwappable = /* see definition */;

template <class I1, class I2, class R = equal_to<>, class P1 = identity, class P2 = identity> concept bool IndirectlyComparable = /* see definition */;

template <class I> concept bool Permutable = /* see definition */;

template <class I1, class I2, class Out, class R = less<>, class P1 = identity, class P2 = identity> concept bool Mergeable = /* see definition */;

template <class I, class R = less<>, class P = identity> concept bool Sortable = /* see definition */;

template <class Iterator> using iterator_traits = /* see definition */;

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 /* unspecified */ advance = /* unspecified */; constexpr /* unspecified */ distance = /* unspecified */; constexpr /* unspecified */ next = /* unspecified */; constexpr /* unspecified */ prev = /* unspecified */; }

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 & x, default_sentinel); constexpr bool operator==( default_sentinel, const counted_iterator & 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 & x, default_sentinel y); constexpr bool operator!=( default_sentinel x, const counted_iterator & 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::Iterator Out> struct iterator_traits<Out>; template <experimental::ranges::InputIterator In> struct iterator_traits<In>; template <experimental::ranges::InputIterator In> requires experimental::ranges::Sentinel<In, In> struct iterator_traits; }

}}

{{langlinks|ja|zh}}