Experimental library header <experimental/ranges/iterator>
From cppreference.com
< cpp | header | experimental
This header is part of the ranges library.
Contents |
[edit]
Defined in namespace
std::experimental::ranges |
[edit] Iterator concepts
specifies that a type is readable by applying operator * (concept) | |
specifies that a value can be written to an iterator's referenced object (concept) | |
specifies that a Semiregular type can be incremented with pre- and post-increment operators (concept) | |
specifies that the increment operation on a WeaklyIncrementable type is equality-preserving and that the type is EqualityComparable (concept) | |
specifies that objects of a type can be incremented and dereferenced (concept) | |
specifies that objects of a type is a sentinel for an Iterator type (concept) | |
specifies that the - operator can be applied to an iterator and a sentinel to calculate their difference in constant time (concept) | |
specifies that a type is an input iterator, that is, its referenced values can be read and it can be both pre- and post-incremented (concept) | |
specifies that a type is an output iterator for a given value type, that is, values of that type can be written to it and it can be both pre- and post-incremented (concept) | |
specifies that an InputIterator is a forward iterator, supporting equality comparison and multi-pass (concept) | |
specifies that a ForwardIterator is a bidirectional iterator, supporting movement backwards (concept) | |
specifies that a BidirectionalIterator is a random-access iterator, supporting advancement in constant time and subscripting (concept) |
[edit] Indirect callable concepts
specifies that a callable type can be invoked with the result of dereferencing a Readable type (concept) | |
specifies that a callable object, when invoked with the result of dereferencing a Readable type, satisfies Predicate (concept) | |
specifies that a callable object, when invoked with the result of dereferencing some Readable types, satisfies Relation (concept) | |
specifies that a callable object, when invoked with the result of dereferencing some Readable types, satisfies StrictWeakOrder (concept) |
[edit] Common algorithm requirements
specifies that values may be moved from a Readable type to a Writable type (concept) | |
specifies that values may be moved from a Readable type to a Writable type and that the move may be performed via an intermediate object (concept) | |
specifies that values may be copied from a Readable type to a Writable type (concept) | |
specifies that values may be copied from a Readable type to a Writable type and that the copy may be performed via an intermediate object (concept) | |
specifies that the values referenced by two Readable types can be swapped (concept) | |
specifies that the values referenced by two Readable types can be compared (concept) | |
specifies the common requirements of algorithms that reorder elements in place (concept) | |
specifies the requirements of algorithms that merge sorted sequences into an output sequence by copying elements (concept) | |
specifies the common requirements of algorithms that permute sequences into ordered sequences (concept) |
[edit] Concept utilities
compute the result of invoking a callable object on the result of dereferencing some set of Readable types (class template) | |
helper template for specifying the constraints on algorithms that accept projections (class template) |
[edit] Iterator primitives
[edit] Iterator utilities
Defined in namespace
std::experimental::ranges | |
casts the result of dereferencing an object to its associated rvalue reference type (customization point object) | |
swap the values referenced by two dereferenceable objects (customization point object) |
[edit] Iterator traits
Defined in namespace
std::experimental::ranges | |
obtains the difference type of a WeaklyIncrementable type (class template) | |
obtains the value type of a Readable type (class template) | |
obtains the iterator category of an input iterator type (class template) | |
compatibility traits class that collects an iterator’s associated types (alias template) | |
obtains a dereferenceable object's associated reference types (alias template) |
[edit] Iterator category tags
Defined in namespace
std::experimental::ranges | |
empty class types used to indicate iterator categories (class) |
[edit] std::iterator_traits specializations
Defined in namespace
std | |
specializes std::iterator_traits for ranges TS iterators (class template specialization) |
[edit] Iterator operations
Defined in namespace
std::experimental::ranges | |
advances an iterator by given distance (function template) | |
returns the distance between an iterator and a sentinel, or between the beginning and the end of a range (function template) | |
increment an iterator (function template) | |
decrement an iterator (function template) |
[edit] Iterator adaptors
Defined in namespace
std::experimental::ranges | |
iterator adaptor for reverse-order traversal (class template) | |
iterator adaptor for insertion at the end of a container (class template) | |
iterator adaptor for insertion at the front of a container (class template) | |
iterator adaptor for insertion into a container (class template) | |
iterator adaptor which dereferences to an rvalue reference (class template) | |
sentinel adaptor for use with move_iterator (class template) | |
adapt an iterator-sentinel pair into a common iterator type for use with legacy algorithms (class template) | |
iterator adaptor that keeps track of its distance from its starting position (class template) | |
empty sentinel type for use with iterator types that know the bound of their range (class) | |
wrapper for a possibly dangling iterator (class template) | |
alias template that wraps the iterator type of an rvalue range with dangling (alias template) | |
sentinel type used with any iterator to denote an infinite range (class) |
[edit] Stream iterators
Defined in namespace
std::experimental::ranges | |
input iterator that reads from std::basic_istream (class template) | |
output iterator that writes to std::basic_ostream (class template) | |
input iterator that reads from std::basic_streambuf (class template) | |
output iterator that writes to std::basic_streambuf (class template) |
[edit] Synopsis
namespace std { namespace experimental { namespace ranges { inline namespace v1 { template <class T> concept bool /* dereferenceable */ // exposition only = requires(T& t) { {*t} -> auto&&; }; namespace { constexpr /* unspecified */ iter_move = /* unspecified */; constexpr /* unspecified */ iter_swap = /* unspecified */; } 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 </* dereferenceable */ T> using reference_t = decltype(*declval<T&>()); template </* dereferenceable */ T> requires /* see definition */ using rvalue_reference_t = decltype(ranges::iter_move(declval<T&>())); template <class In> concept bool Readable = /* see definition */; template <class Out, class T> concept bool Writable = /* see definition */; template <class I> concept bool WeaklyIncrementable = /* see definition */; template <class I> concept bool Incrementable = /* see definition */; template <class I> 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 <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 = /* 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<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::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; }