Extensions for ranges - cppreference.com

##### cppreference.com

##### Search

Create account

##### Namespaces

- Page
- Discussion

##### Variants

##### Views

- View
- Edit
- History

##### Actions

# Extensions for ranges

From cppreference.com
< cpp‎ | experimental

The C++ Extensions for Ranges, ISO/IEC TS 21425:XXXX, 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.

#### [edit] 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.

#### [edit] Concepts

##### Core language concepts
Defined in header `<experimental/ranges/concepts>`
Defined in namespace `std::experimental::ranges`
Same | specifies that a type is the same as another type (concept) [edit]
DerivedFrom | specifies that a type is derived from another type (concept) [edit]
ConvertibleTo | specifies that a type is implicitly convertible to another type (concept) [edit]
CommonReference | specifies that two types share a common reference type (concept) [edit]
Common | specifies that two types share a common type (concept) [edit]
Integral | specifies that a type is an integral type (concept) [edit]
SignedIntegral | specifies that a type is a integral type that is signed (concept) [edit]
UnsignedIntegral | specifies that a type is an integral type that is not signed (concept) [edit]
Assignable | specifies that a type is assignable from another type (concept) [edit]
Swappable | specifies that a type can be swapped or that two types can be swapped with each other (concept) [edit]
##### Comparison concepts
Defined in header `<experimental/ranges/concepts>`
Defined in namespace `std::experimental::ranges`
Boolean | specifies that a type can be used in Boolean contexts (concept) [edit]
WeaklyEqualityComparable | specifies that two types can be compared for equality using operators == and != (concept) [edit]
EqualityComparable | specifies that operator == is an equivalence relation (concept) [edit]
StrictTotallyOrdered | specifies that the comparison operators on the type yield a total order (concept) [edit]
##### Object concepts
Defined in header `<experimental/ranges/concepts>`
Defined in namespace `std::experimental::ranges`
Destructible | specifies that an object of the type can be destroyed and have its address taken with unary & (concept) [edit]
Constructible | specifies that a variable of the type can be constructed from or bound to a set of argument types (concept) [edit]
DefaultConstructible | specifies that an object of a type can be default constructed (concept) [edit]
MoveConstructible | specifies that an object of a type can be move constructed (concept) [edit]
CopyConstructible | specifies that an object of a type can be copy constructed and move constructed (concept) [edit]
Movable | specifies that an object of a type can be moved and swapped (concept) [edit]
Copyable | specifies that an object of a type can be copied, moved, and swapped (concept) [edit]
Semiregular | specifies that an object of a type can be copied, moved, swapped, and default constructed (concept) [edit]
Regular | specifies that a type is regular, that is, it is both `Semiregular` and `EqualityComparable` (concept) [edit]
##### Callable concepts
Defined in header `<experimental/ranges/concepts>`
Defined in namespace `std::experimental::ranges`
InvocableRegularInvocable | specifies that a callable type can be invoked with a given set of argument types (concept) [edit]
Predicate | specifies that a callable type is a Boolean predicate (concept) [edit]
Relation | specifies that a callable type is a binary relation (concept) [edit]
StrictWeakOrder | specifies that a `Relation` imposes a strict weak ordering (concept) [edit]
##### Random number generator concept
Defined in header `<experimental/ranges/random>`
Defined in namespace `std::experimental::ranges`
UniformRandomNumberGenerator | specifies that a type qualifies as a uniform random number generator (concept) [edit]

#### [edit] General utilities

##### Utility components
Defined in header `<experimental/ranges/utility>`
Defined in namespace `std::experimental::ranges`
swap | swaps the value of two objects (customization point object) [edit]
exchange | replaces the argument with a new value and returns its previous value (function template) [edit]
##### Function objects
Defined in header `<experimental/ranges/functional>`
Defined in namespace `std::experimental::ranges`
invoke | invokes a `Callable` object with the given arguments (function template) [edit]
equal_to | function object implementing x == y (class template) [edit]
not_equal_to | function object implementing x != y (class template) [edit]
greater | function object implementing x > y (class template) [edit]
less | function object implementing x < y (class template) [edit]
greater_equal | function object implementing x >= y (class template) [edit]
less_equal | function object implementing x <= y (class template) [edit]
identity | function object that returns its argument unchanged (class) [edit]
##### Metaprogramming and type traits
Defined in header `<type_traits>`
Defined in namespace `std`
is_swappable_withis_swappableis_nothrow_swappable_withis_nothrow_swappable | checks if objects of a type can be swapped with objects of same or different type (class template) [edit]
basic_common_referencecommon_reference | determine the common reference type of a set of types (class template) [edit]
common_type | determine the common type of a set of types (class template) [edit]
##### Tagged pairs and tuples
Defined in namespace `std::experimental::ranges`
Defined in header `<experimental/ranges/utility>`
TagSpecifier | specifies that a type is a tag specifier (concept) [edit]
TaggedType | specifies that a type represents a tag specifier and its element type (concept) [edit]
tagged | augument a tuple-like type with named accessors (class template) [edit]
tagged_pair | alias template for a tagged std::pair (alias template) [edit]
make_tagged_pair | convenience function for creating a `tagged_pair` (function template) [edit]
Defined in header `<experimental/ranges/tuple>`
tagged_tuple | alias template for a tagged std::tuple (alias template) [edit]
make_tagged_tuple | convenience function for creating a `tagged_tuple` (function template) [edit]
Defined in header `<experimental/ranges/algorithm>`
Defined in namespace `std::experimental::ranges::tag`
inin1in2outout1out2funminmaxbeginend | tag specifiers for use with ranges::tagged (class) [edit]

#### [edit] Iterators

Defined in header `<experimental/ranges/iterator>`
##### Iterator and range concepts
Defined in namespace `std::experimental::ranges`
###### Iterator concepts
Readable | specifies that a type is readable by applying operator `*` (concept) [edit]
Writable | specifies that a value can be written to an iterator's referenced object (concept) [edit]
WeaklyIncrementable | specifies that a type can be incremented with pre- and post-increment operators (concept) [edit]
Incrementable | specifies that the increment operation on a `WeaklyIncrementable` type is equality-preserving and that the type is `EqualityComparable` (concept) [edit]
Iterator | specifies that objects of a type can be incremented and dereferenced (concept) [edit]
Sentinel | specifies that objects of a type is a sentinel for an `Iterator` type (concept) [edit]
SizedSentinel | specifies that the `-` operator can be applied to an iterator and a sentinel to calculate their difference in constant time (concept) [edit]
InputIterator | 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) [edit]
OutputIterator | 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) [edit]
ForwardIterator | specifies that an `InputIterator` is a forward iterator, supporting equality comparison and multi-pass (concept) [edit]
BidirectionalIterator | specifies that a `ForwardIterator` is a bidirectional interator, supporting movement backwards (concept) [edit]
RandomAccessIterator | specifies that a `BidirectionalIterator` is a random-access interator, supporting advancement in constant time and subscripting (concept) [edit]
###### Indirect callable concepts
IndirectInvocableIndirectRegularInvocable | specifies that a callable type can be invoked with the result of dereferencing some `Readable` types (concept) [edit]
IndirectPredicate | specifies that a callable object, when invoked with the result of dereferencing some `Readable` types, satisfies `Predicate` (concept) [edit]
IndirectRelation | specifies that a callable object, when invoked with the result of dereferencing some `Readable` types, satisfies `Relation` (concept) [edit]
IndirectStrictWeakOrder | specifies that a callable object, when invoked with the result of dereferencing some `Readable` types, satisfies `StrictWeakOrder` (concept) [edit]
###### Common algorithm requirements
IndirectlyMovable | specifies that values may be moved from a `Readable` type to a `Writable` type (concept) [edit]
IndirectlyMovableStorable | 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) [edit]
IndirectlyCopyable | specifies that values may be copied from a `Readable` type to a `Writable` type (concept) [edit]
IndirectlyCopyableStorable | 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) [edit]
IndirectlySwappable | specifies that the values referenced by two `Readable` types can be swapped (concept) [edit]
IndirectlyComparable | specifies that the values referenced by two `Readable` types can be compared (concept) [edit]
Permutable | specifies the common requirements of algorithms that reorder elements in place (concept) [edit]
Mergeable | specifies the requirements of algorithms that merge sorted sequences into an output sequence by copying elements (concept) [edit]
Sortable | specifies the common requirements of algorithms that permute sequences into ordered sequences (concept) [edit]
###### Range concepts
Range | specifies that a type is a range, that is, it provides a `begin` iterator and an `end` sentinel (concept) [edit]
SizedRange | specifies that a range knows its size in constant time (concept) [edit]
View | specifies that a range is a view, that is, it has constant time copy/move/assignment (concept) [edit]
BoundedRange | specifies that a range has identical iterator and sentinel types (concept) [edit]
InputRange | specifies a range whose iterator type satisfies `InputIterator` (concept) [edit]
OutputRange | specifies a range whose iterator type satisfies `OutputIterator` (concept) [edit]
ForwardRange | specifies a range whose iterator type satisfies `ForwardIterator` (concept) [edit]
BidirectionalRange | specifies a range whose iterator type satisfies `BidirectionalIterator` (concept) [edit]
RandomAccessRange | specifies a range whose iterator type satisfies `RandomAccessIterator` (concept) [edit]
###### Concept utilities
indirect_result_of | compute the result of invoking a callable object on the result of dereferencing some set of `Readable` types (class template) [edit]
projected | helper template for specifying the constraints on algorithms that accept projections (class template) [edit]
disable_sized_sentinel | provides a mechanism to declare that an iterator-sentinel pair does not satisfy `SizedSentinel` (variable template) [edit]
disable_sized_range | Provide a mechanism to declare that a range does not meet `SizedRange` (variable template) [edit]
view_base | empty base class to signify that a class is a view (class) [edit]
enable_view | helper trait to differentiate views from other ranges (class template) [edit]
##### Iterator primitives
###### Iterator utilities
Defined in namespace `std::experimental::ranges`
iter_move | casts the result of dereferencing an object to its associated rvalue reference type (customization point object) [edit]
iter_swap | swap the values referenced by two dereferenceable objects (customization point object) [edit]
###### Iterator traits
Defined in namespace `std::experimental::ranges`
difference_type | obtains the difference type of a `WeaklyIncrementable` type (class template) [edit]
value_type | obtains the value type of a `Readable` type (class template) [edit]
iterator_category | obtains the iterator category of an input iterator type (class template) [edit]
iterator_traits | compatibility traits class that collects an iterator’s associated types (alias template) [edit]
reference_t | obtains a dereferenceable object's reference type (alias template) [edit]
rvalue_reference_t | obtains a dereferenceable object's rvalue reference type (alias template) [edit]
iter_common_reference_t | compute the common reference type of a `Readable` object's reference type and an lvalue reference to its value type (alias template) [edit]
is_indirectly_movableis_nothrow_indirectly_movable | tests whether two types satisfy `IndirectlyMovable` (class template) [edit]
is_indirectly_swappableis_nothrow_indirectly_swappable | tests whether two types satisfy `IndirectlySwappable` (class template) [edit]
###### Iterator category tags
Defined in namespace `std::experimental::ranges`
input_iterator_tagoutput_iterator_tagforward_iterator_tagbidirectional_iterator_tagrandom_access_iterator_tag | empty class types used to indicate iterator categories (class) [edit]
###### std::iterator_traits specializations
Defined in namespace `std`
std::iterator_traits<InputIterator>std::iterator_traits<OutputIterator> | specializes std::iterator_traits for ranges TS iterators (class template specialization) [edit]
###### Iterator operations
Defined in namespace `std::experimental::ranges`
advance | advances an iterator by given distance (function template) [edit]
distance | returns the distance between an iterator and a sentinel, or between the beginning and the end of a range (function template) [edit]
next | increment an iterator (function template) [edit]
prev | decrement an iterator (function template) [edit]
##### Iterator adaptors
Defined in namespace `std::experimental::ranges`
reverse_iterator | iterator adaptor for reverse-order traversal (class template) [edit]
back_insert_iterator | iterator adaptor for insertion at the end of a container (class template) [edit]
front_insert_iterator | iterator adaptor for insertion at the front of a container (class template) [edit]
insert_iterator | iterator adaptor for insertion into a container (class template) [edit]
move_iterator | iterator adaptor which dereferences to an rvalue reference (class template) [edit]
move_sentinel | sentinel adaptor for use with `move_iterator` (class template) [edit]
common_iterator | adapt an iterator-sentinel pair into a common iterator type for use with legacy algorithms (class template) [edit]
counted_iterator | iterator adaptor that keeps track of its distance from its starting position (class template) [edit]
default_sentinel | empty sentinel type for use with iterator types that know the bound of their range (class) [edit]
dangling | wrapper for a possibly dangling iterator (class template) [edit]
safe_iterator_t | alias template that wraps the iterator type of an rvalue range with `dangling` (alias template) [edit]
unreachable | sentinel type used with any iterator to denote an infinite range (class) [edit]
##### Stream iterators
Defined in namespace `std::experimental::ranges`
istream_iterator | input iterator that reads from std::basic_istream (class template) [edit]
ostream_iterator | output iterator that writes to std::basic_ostream (class template) [edit]
istreambuf_iterator | input iterator that reads from std::basic_streambuf (class template) [edit]
ostreambuf_iterator | output iterator that writes to std::basic_streambuf (class template) [edit]
##### Range access
Defined in namespace `std::experimental::ranges`
begincbegin | returns an iterator to the beginning of a range (customization point object) [edit]
endcend | returns an iterator to the end of a range (customization point object) [edit]
rbegincrbegin | returns a reverse iterator to a range (customization point object) [edit]
rendcrend | returns a reverse end iterator to a range (customization point object) [edit]
##### Range primitives
Defined in namespace `std::experimental::ranges`
iterator_t | obtains the iterator type of a range (alias template) [edit]
sentinel_t | obtains the sentinel type of a range (alias template) [edit]
distance | returns the distance between an iterator and a sentinel, or between the beginning and the end of a range (function template) [edit]
size | obtains the size of a range whose size can be calculated in constant time (customization point object) [edit]
empty | checks whether a range is empty (customization point object) [edit]
datacdata | obtains a pointer to the beginning of a contiguous range (customization point object) [edit]

#### [edit] Algorithms

Defined in header `<experimental/ranges/algorithm>`
##### Non-modifying sequence operations
Defined in namespace `std::experimental::ranges`
all_ofany_ofnone_of | checks if a predicate is true for all, any or none of the elements in a range (function template) [edit]
for_each | applies a function to a range of elements (function template) [edit]
countcount_if | returns the number of elements satisfying specific criteria (function template) [edit]
mismatch | finds the first position where two ranges differ (function template) [edit]
equal | determines if two sets of elements are the same (function template) [edit]
findfind_iffind_if_not | finds the first element satisfying specific criteria (function template) [edit]
find_end | finds the last sequence of elements in a certain range (function template) [edit]
find_first_of | searches for any one of a set of elements (function template) [edit]
adjacent_find | finds the first two adjacent items that are equal (or satisfy a given predicate) (function template) [edit]
search | searches for a range of elements (function template) [edit]
search_n | searches for a number consecutive copies of an element in a range (function template) [edit]
##### Modifying sequence operations
Defined in namespace `std::experimental::ranges`
copycopy_if | copies a range of elements to a new location (function template) [edit]
copy_n | copies a number of elements to a new location (function template) [edit]
copy_backward | copies a range of elements in backwards order (function template) [edit]
move | moves a range of elements to a new location (function template) [edit]
move_backward | moves a range of elements to a new location in backwards order (function template) [edit]
fill | assigns a range of elements a certain value (function template) [edit]
fill_n | assigns a value to a number of elements (function template) [edit]
transform | applies a function to a range of elements (function template) [edit]
generate | saves the result of a function in a range (function template) [edit]
generate_n | saves the result of N applications of a function (function template) [edit]
removeremove_if | removes elements satisfying specific criteria (function template) [edit]
remove_copyremove_copy_if | copies a range of elements omitting those that satisfy specific criteria (function template) [edit]
replacereplace_if | replaces all values satisfying specific criteria with another value (function template) [edit]
replace_copyreplace_copy_if | copies a range, replacing elements satisfying specific criteria with another value (function template) [edit]
swap_ranges | swaps two ranges of elements (function template) [edit]
reverse | reverses the order of elements in a range (function template) [edit]
reverse_copy | creates a copy of a range that is reversed (function template) [edit]
rotate | rotates the order of elements in a range (function template) [edit]
rotate_copy | copies and rotate a range of elements (function template) [edit]
shuffle | randomly re-orders elements in a range (function template) [edit]
unique | removes consecutive duplicate elements in a range (function template) [edit]
unique_copy | creates a copy of some range of elements that contains no consecutive duplicates (function template) [edit]
##### Partitioning operations
Defined in namespace `std::experimental::ranges`
is_partitioned | determines if the range is partitioned by the given predicate (function template) [edit]
partition | divides a range of elements into two groups (function template) [edit]
partition_copy | copies a range dividing the elements into two groups (function template) [edit]
stable_partition | divides elements into two groups while preserving their relative order (function template) [edit]
partition_point | locates the partition point of a partitioned range (function template) [edit]
##### Sorting operations
Defined in namespace `std::experimental::ranges`
is_sorted | checks whether a range is sorted into ascending order (function template) [edit]
is_sorted_until | finds the largest sorted subrange (function template) [edit]
sort | sorts a range into ascending order (function template) [edit]
partial_sort | sorts the first N elements of a range (function template) [edit]
partial_sort_copy | copies and partially sorts a range of elements (function template) [edit]
stable_sort | sorts a range of elements while preserving order between equal elements (function template) [edit]
nth_element | partially sorts the given range making sure that it is partitioned by the given element (function template) [edit]
##### Binary search operations (on sorted ranges)
Defined in namespace `std::experimental::ranges`
lower_bound | returns an iterator to the first element not less than the given value (function template) [edit]
upper_bound | returns an iterator to the first element greater than a certain value (function template) [edit]
binary_search | determines if an element exists in a certain range (function template) [edit]
equal_range | returns range of elements matching a specific key (function template) [edit]
##### Set operations (on sorted ranges)
Defined in namespace `std::experimental::ranges`
merge | merges two sorted ranges (function template) [edit]
inplace_merge | merges two ordered ranges in-place (function template) [edit]
includes | returns true if one set is a subset of another (function template) [edit]
set_difference | computes the difference between two sets (function template) [edit]
set_intersection | computes the intersection of two sets (function template) [edit]
set_symmetric_difference | computes the symmetric difference between two sets (function template) [edit]
set_union | computes the union of two sets (function template) [edit]
##### Heap operations
Defined in namespace `std::experimental::ranges`
is_heap | checks if the given range is a max heap (function template) [edit]
is_heap_until | finds the largest subrange that is a max heap (function template) [edit]
make_heap | creates a max heap out of a range of elements (function template) [edit]
push_heap | adds an element to a max heap (function template) [edit]
pop_heap | removes the largest element from a max heap (function template) [edit]
sort_heap | turns a max heap into a range of elements sorted in ascending order (function template) [edit]
##### Minimum/maximum operations
Defined in namespace `std::experimental::ranges`
max | returns the greater of the given values (function template) [edit]
max_element | returns the largest element in a range (function template) [edit]
min | returns the smaller of the given values (function template) [edit]
min_element | returns the smallest element in a range (function template) [edit]
minmax | returns the smaller and larger of two elements (function template) [edit]
minmax_element | returns the smallest and the largest elements in a range (function template) [edit]
lexicographical_compare | returns true if one range is lexicographically less than another (function template) [edit]
is_permutation | determines if a sequence is a permutation of another sequence (function template) [edit]
next_permutation | generates the next greater lexicographic permutation of a range of elements (function template) [edit]
prev_permutation | generates the next smaller lexicographic permutation of a range of elements (function template) [edit]

Retrieved from "http://en.cppreference.com/mwiki/index.php?title=cpp/experimental/ranges&oldid=89682"