Extensions for ranges
From cppreference.com
<
cpp
|
experimental
The C++ Extensions for Ranges, ISO/IEC TS 21425:2017, specifies one modification to the core language and defines new components for the C++ standard library listed on this page.
The Ranges TS is based on the C++14 standard as modified by the Concepts TS .
Core language changes
The Ranges TS modifies the specification of the range-based for loop to permit differently typed begin and end iterators. This change permits the use of sentinels and is also present in C++17.
Concepts
Core language concepts |
|
|
Defined in header
<experimental/ranges/concepts>
|
|
|
Defined in namespace
std::experimental::ranges
|
|
|
specifies that a type is the same as another type
(concept) |
|
|
specifies that a type is derived from another type
(concept) |
|
|
specifies that a type is implicitly convertible to another type
(concept) |
|
|
specifies that two types share a common reference type
(concept) |
|
|
specifies that two types share a common type
(concept) |
|
|
specifies that a type is an integral type
(concept) |
|
|
specifies that a type is an integral type that is signed
(concept) |
|
|
specifies that a type is an integral type that is not signed
(concept) |
|
|
specifies that a type is assignable from another type
(concept) |
|
|
specifies that a type can be swapped or that two types can be swapped with each other
(concept) |
|
Comparison concepts |
|
|
Defined in header
<experimental/ranges/concepts>
|
|
|
Defined in namespace
std::experimental::ranges
|
|
|
specifies that a type can be used in Boolean contexts
(concept) |
|
|
specifies that two types can be compared for equality using operators
==
and
!
=
(concept) |
|
|
specifies that operator
==
is an equivalence relation
(concept) |
|
|
specifies that the comparison operators on the type yield a total order
(concept) |
|
Object concepts |
|
|
Defined in header
<experimental/ranges/concepts>
|
|
|
Defined in namespace
std::experimental::ranges
|
|
|
specifies that an object of the type can be destroyed
(concept) |
|
|
specifies that a variable of the type can be constructed from or bound to a set of argument types
(concept) |
|
|
specifies that an object of a type can be default constructed
(concept) |
|
|
specifies that an object of a type can be move constructed
(concept) |
|
|
specifies that an object of a type can be copy constructed and move constructed
(concept) |
|
|
specifies that an object of a type can be moved and swapped
(concept) |
|
|
specifies that an object of a type can be copied, moved, and swapped
(concept) |
|
|
specifies that an object of a type can be copied, moved, swapped, and default constructed
(concept) |
|
specifies that a type is regular, that is, it is both
Semiregular
and
EqualityComparable
(concept) |
|
Callable concepts |
|
|
Defined in header
<experimental/ranges/concepts>
|
|
|
Defined in namespace
std::experimental::ranges
|
|
|
specifies that a callable type can be invoked with a given set of argument types
(concept) |
|
|
specifies that a callable type is a Boolean predicate
(concept) |
|
|
specifies that a callable type is a binary relation
(concept) |
|
specifies that a
Relation
imposes a strict weak ordering
(concept) |
|
Random number generator concept |
|
|
Defined in header
<experimental/ranges/random>
|
|
|
Defined in namespace
std::experimental::ranges
|
|
|
specifies that a type qualifies as a uniform random number generator
(concept) |
|
General utilities
Utility components |
|
|
Defined in header
<experimental/ranges/utility>
|
|
|
Defined in namespace
std::experimental::ranges
|
|
|
swaps the value of two objects
(customization point object) |
|
|
replaces the argument with a new value and returns its previous value
(function template) |
|
Function objects |
|
|
Defined in header
<experimental/ranges/functional>
|
|
|
Defined in namespace
std::experimental::ranges
|
|
|
invokes a
Callable
object with the given arguments
(function template) |
|
|
function object implementing
x
==
y
(class template) |
|
|
function object implementing
x
!
=
y
(class template) |
|
|
function object implementing
x
>
y
(class template) |
|
|
function object implementing
x
<
y
(class template) |
|
|
function object implementing
x
>=
y
(class template) |
|
|
function object implementing
x
<=
y
(class template) |
|
|
function object that returns its argument unchanged
(class) |
|
Metaprogramming and type traits |
|
|
Defined in header
<experimental/ranges/type_traits>
|
|
|
Defined in namespace
std::experimental::ranges
|
|
|
checks if objects of a type can be swapped with objects of same or different type
(class template) |
|
|
determine the common reference type of a set of types
(class template) |
|
|
determine the common type of a set of types
(class template) |
|
Tagged pairs and tuples |
|
|
Defined in header
<experimental/ranges/utility>
|
|
|
Defined in namespace
std::experimental::ranges
|
|
|
specifies that a type is a tag specifier
(concept) |
|
|
specifies that a type represents a tag specifier and its element type
(concept) |
|
|
augument a tuple-like type with named accessors
(class template) |
|
|
alias template for a tagged
std::pair
(alias template) |
|
convenience function for creating a
tagged_pair
(function template) |
|
|
Defined in header
<experimental/ranges/tuple>
|
|
|
alias template for a tagged
std::tuple
(alias template) |
|
convenience function for creating a
tagged_tuple
(function template) |
|
|
Defined in header
<experimental/ranges/algorithm>
|
|
|
Defined in namespace
std::experimental::ranges::tag
|
|
|
tag specifiers for use with
ranges::tagged
(class) |
|
Iterators
|
Defined in header
<experimental/ranges/iterator>
|
|
|
|
|
|
Defined in namespace
std::experimental::ranges
|
|
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) |
|
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) |
|
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) |
|
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) |
|
Iterator primitives |
|
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) |
|
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) |
|
Iterator category tags |
|
|
Defined in namespace
std::experimental::ranges
|
|
|
empty class types used to indicate iterator categories
(class) |
|
std::iterator_traits specializations |
|
|
Defined in namespace
std
|
|
|
specializes
std::iterator_traits
for ranges TS iterators
(class template specialization) |
|
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) |
|
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) |
|
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) |
|
Ranges
|
Defined in header
<experimental/ranges/range>
|
|
Range concepts |
|
specifies that a type is a range, that is, it provides a
begin
iterator and an
end
sentinel
(concept) |
|
|
specifies that a range knows its size in constant time
(concept) |
|
|
specifies that a range is a view, that is, it has constant time copy/move/assignment
(concept) |
|
|
specifies that a range has identical iterator and sentinel types
(concept) |
|
specifies a range whose iterator type satisfies
InputIterator
(concept) |
|
specifies a range whose iterator type satisfies
OutputIterator
(concept) |
|
specifies a range whose iterator type satisfies
ForwardIterator
(concept) |
|
specifies a range whose iterator type satisfies
BidirectionalIterator
(concept) |
|
specifies a range whose iterator type satisfies
RandomAccessIterator
(concept) |
|
Range access |
|
|
Defined in namespace
std::experimental::ranges
|
|
|
returns an iterator to the beginning of a range
(customization point object) |
|
|
returns an iterator to the end of a range
(customization point object) |
|
|
returns a reverse iterator to a range
(customization point object) |
|
|
returns a reverse end iterator to a range
(customization point object) |
|
Range primitives |
|
|
Defined in namespace
std::experimental::ranges
|
|
|
obtains the size of a range whose size can be calculated in constant time
(customization point object) |
|
|
checks whether a range is empty
(customization point object) |
|
|
obtains a pointer to the beginning of a contiguous range
(customization point object) |
|
|
obtains the iterator and sentinel types of a range
(alias template) |
|
Algorithms
|
Defined in header
<experimental/ranges/algorithm>
|
|
Non-modifying sequence operations |
|
|
Defined in namespace
std::experimental::ranges
|
|
|
checks if a predicate is
true
for all, any or none of the elements in a range
(function template) |
|
|
applies a function to a range of elements
(function template) |
|
|
returns the number of elements satisfying specific criteria
(function template) |
|
|
finds the first position where two ranges differ
(function template) |
|
|
determines if two sets of elements are the same
(function template) |
|
|
returns
true
if one range is lexicographically less than another
(function template) |
|
|
finds the first element satisfying specific criteria
(function template) |
|
|
finds the last sequence of elements in a certain range
(function template) |
|
|
searches for any one of a set of elements
(function template) |
|
|
finds the first two adjacent items that are equal (or satisfy a given predicate)
(function template) |
|
|
searches for a range of elements
(function template) |
|
|
searches for a number consecutive copies of an element in a range
(function template) |
|
Modifying sequence operations |
|
|
Defined in namespace
std::experimental::ranges
|
|
|
copies a range of elements to a new location
(function template) |
|
|
copies a number of elements to a new location
(function template) |
|
|
copies a range of elements in backwards order
(function template) |
|
|
moves a range of elements to a new location
(function template) |
|
|
moves a range of elements to a new location in backwards order
(function template) |
|
|
assigns a range of elements a certain value
(function template) |
|
|
assigns a value to a number of elements
(function template) |
|
|
applies a function to a range of elements
(function template) |
|
|
saves the result of a function in a range
(function template) |
|
|
saves the result of N applications of a function
(function template) |
|
|
removes elements satisfying specific criteria
(function template) |
|
|
copies a range of elements omitting those that satisfy specific criteria
(function template) |
|
|
replaces all values satisfying specific criteria with another value
(function template) |
|
|
copies a range, replacing elements satisfying specific criteria with another value
(function template) |
|
|
swaps two ranges of elements
(function template) |
|
|
reverses the order of elements in a range
(function template) |
|
|
creates a copy of a range that is reversed
(function template) |
|
|
rotates the order of elements in a range
(function template) |
|
|
copies and rotate a range of elements
(function template) |
|
|
randomly re-orders elements in a range
(function template) |
|
|
removes consecutive duplicate elements in a range
(function template) |
|
|
creates a copy of some range of elements that contains no consecutive duplicates
(function template) |
|
Partitioning operations |
|
|
Defined in namespace
std::experimental::ranges
|
|
|
determines if the range is partitioned by the given predicate
(function template) |
|
|
divides a range of elements into two groups
(function template) |
|
|
copies a range dividing the elements into two groups
(function template) |
|
|
divides elements into two groups while preserving their relative order
(function template) |
|
|
locates the partition point of a partitioned range
(function template) |
|
Sorting operations |
|
|
Defined in namespace
std::experimental::ranges
|
|
|
checks whether a range is sorted into ascending order
(function template) |
|
|
finds the largest sorted subrange
(function template) |
|
|
sorts a range into ascending order
(function template) |
|
|
sorts the first N elements of a range
(function template) |
|
|
copies and partially sorts a range of elements
(function template) |
|
|
sorts a range of elements while preserving order between equal elements
(function template) |
|
|
partially sorts the given range making sure that it is partitioned by the given element
(function template) |
|
Binary search operations (on sorted ranges) |
|
|
Defined in namespace
std::experimental::ranges
|
|
|
returns an iterator to the first element
not less
than the given value
(function template) |
|
|
returns an iterator to the first element
greater
than a certain value
(function template) |
|
|
determines if an element exists in a certain range
(function template) |
|
|
returns range of elements matching a specific key
(function template) |
|
Set operations (on sorted ranges) |
|
|
Defined in namespace
std::experimental::ranges
|
|
|
merges two sorted ranges
(function template) |
|
|
merges two ordered ranges in-place
(function template) |
|
|
returns
true
if one set is a subset of another
(function template) |
|
|
computes the difference between two sets
(function template) |
|
|
computes the intersection of two sets
(function template) |
|
|
computes the symmetric difference between two sets
(function template) |
|
|
computes the union of two sets
(function template) |
|
Heap operations |
|
|
Defined in namespace
std::experimental::ranges
|
|
|
checks if the given range is a max heap
(function template) |
|
|
finds the largest subrange that is a max heap
(function template) |
|
|
creates a max heap out of a range of elements
(function template) |
|
|
adds an element to a max heap
(function template) |
|
|
removes the largest element from a max heap
(function template) |
|
|
turns a max heap into a range of elements sorted in ascending order
(function template) |
|
Minimum/maximum operations |
|
|
Defined in namespace
std::experimental::ranges
|
|
|
returns the greater of the given values
(function template) |
|
|
returns the largest element in a range
(function template) |
|
|
returns the smaller of the given values
(function template) |
|
|
returns the smallest element in a range
(function template) |
|
|
returns the smaller and larger of two elements
(function template) |
|
|
returns the smallest and the largest elements in a range
(function template) |
|
Permutation operations |
|
|
Defined in namespace
std::experimental::ranges
|
|
|
determines if a sequence is a permutation of another sequence
(function template) |
|
|
generates the next greater lexicographic permutation of a range of elements
(function template) |
|
|
generates the next smaller lexicographic permutation of a range of elements
(function template) |
|