Constrained algorithms (since C++20)
From cppreference.com
C++20 provides constrained versions of most algorithms in the namespace std::ranges
. In these algorithms, a range can be specified as either a Iterator
-Sentinel
pair or as a single Range
argument, and projections and pointer-to-member callables are supported. Additionally, the return type of most algorithms have been changed to return all potentially useful information computed during the execution of the algorithm.
Contents |
[edit] Algorithm concepts and utilities
The header <iterator> provides a set of concepts and related utility templates designed to ease constraining common algorithm operations.
Defined in header
<iterator> | |
Defined in namespace
std | |
Indirect callable concepts | |
specifies that a callable type can be invoked with the result of dereferencing a Readable type (concept) | |
specifies that a callable type, when invoked with the result of dereferencing a Readable type, satisfies Predicate (concept) | |
specifies that a callable type, when invoked with the result of dereferencing two Readable types, satisfies Predicate (concept) | |
specifies that a callable type, when invoked with the result of dereferencing two 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) | |
Utilities | |
computes the result of invoking a callable object on the result of dereferencing some set of Readable types (alias template) | |
helper template for specifying the constraints on algorithms that accept projections (class template) |
[edit] Constrained algorithms
Defined in header
<algorithm> | |
Defined in namespace
std::ranges | |
Non-modifying sequence operations | |
checks if a predicate is true for all, any or none of the elements in a range (niebloid) | |
applies a function to a range of elements (niebloid) | |
returns the number of elements satisfying specific criteria (niebloid) | |
finds the first position where two ranges differ (niebloid) | |
determines if two sets of elements are the same (niebloid) | |
returns true if one range is lexicographically less than another (niebloid) | |
finds the first element satisfying specific criteria (niebloid) | |
finds the last sequence of elements in a certain range (niebloid) | |
searches for any one of a set of elements (niebloid) | |
finds the first two adjacent items that are equal (or satisfy a given predicate) (niebloid) | |
searches for a range of elements (niebloid) | |
searches for a number consecutive copies of an element in a range (niebloid) | |
Modifying sequence operations | |
copies a range of elements to a new location (niebloid) | |
copies a number of elements to a new location (niebloid) | |
copies a range of elements in backwards order (niebloid) | |
moves a range of elements to a new location (niebloid) | |
moves a range of elements to a new location in backwards order (niebloid) | |
assigns a range of elements a certain value (niebloid) | |
assigns a value to a number of elements (niebloid) | |
applies a function to a range of elements (niebloid) | |
saves the result of a function in a range (niebloid) | |
saves the result of N applications of a function (niebloid) | |
removes elements satisfying specific criteria (niebloid) | |
copies a range of elements omitting those that satisfy specific criteria (niebloid) | |
replaces all values satisfying specific criteria with another value (niebloid) | |
copies a range, replacing elements satisfying specific criteria with another value (niebloid) | |
swaps two ranges of elements (niebloid) | |
reverses the order of elements in a range (niebloid) | |
creates a copy of a range that is reversed (niebloid) | |
rotates the order of elements in a range (niebloid) | |
copies and rotate a range of elements (niebloid) | |
randomly re-orders elements in a range (niebloid) | |
removes consecutive duplicate elements in a range (niebloid) | |
creates a copy of some range of elements that contains no consecutive duplicates (niebloid) | |
Partitioning operations | |
determines if the range is partitioned by the given predicate (niebloid) | |
divides a range of elements into two groups (niebloid) | |
copies a range dividing the elements into two groups (niebloid) | |
divides elements into two groups while preserving their relative order (niebloid) | |
locates the partition point of a partitioned range (niebloid) | |
Sorting operations | |
checks whether a range is sorted into ascending order (niebloid) | |
finds the largest sorted subrange (niebloid) | |
sorts a range into ascending order (niebloid) | |
sorts the first N elements of a range (niebloid) | |
copies and partially sorts a range of elements (niebloid) | |
sorts a range of elements while preserving order between equal elements (niebloid) | |
partially sorts the given range making sure that it is partitioned by the given element (niebloid) | |
Binary search operations (on sorted ranges) | |
returns an iterator to the first element not less than the given value (niebloid) | |
returns an iterator to the first element greater than a certain value (niebloid) | |
determines if an element exists in a certain range (niebloid) | |
returns range of elements matching a specific key (niebloid) | |
Set operations (on sorted ranges) | |
merges two sorted ranges (niebloid) | |
merges two ordered ranges in-place (niebloid) | |
returns true if one set is a subset of another (niebloid) | |
computes the difference between two sets (niebloid) | |
computes the intersection of two sets (niebloid) | |
computes the symmetric difference between two sets (niebloid) | |
computes the union of two sets (niebloid) | |
Heap operations | |
checks if the given range is a max heap (niebloid) | |
finds the largest subrange that is a max heap (niebloid) | |
creates a max heap out of a range of elements (niebloid) | |
adds an element to a max heap (niebloid) | |
removes the largest element from a max heap (niebloid) | |
turns a max heap into a range of elements sorted in ascending order (niebloid) | |
Minimum/maximum operations | |
returns the greater of the given values (niebloid) | |
returns the largest element in a range (niebloid) | |
returns the smaller of the given values (niebloid) | |
returns the smallest element in a range (niebloid) | |
returns the smaller and larger of two elements (niebloid) | |
returns the smallest and the largest elements in a range (niebloid) | |
Permutation operations | |
determines if a sequence is a permutation of another sequence (niebloid) | |
generates the next greater lexicographic permutation of a range of elements (niebloid) | |
generates the next smaller lexicographic permutation of a range of elements (niebloid) |
[edit] Constrained uninitialized memory algorithms
Defined in header
<memory> | |
Defined in namespace
std::ranges | |
(C++20) |
copies a range of objects to an uninitialized area of memory (niebloid) |
(C++20) |
copies a number of objects to an uninitialized area of memory (niebloid) |
(C++20) |
copies an object to an uninitialized area of memory, defined by a range (niebloid) |
(C++20) |
copies an object to an uninitialized area of memory, defined by a start and a count (niebloid) |
(C++20) |
moves a range of objects to an uninitialized area of memory (niebloid) |
(C++20) |
moves a number of objects to an uninitialized area of memory (niebloid) |
constructs objects by default-initialization in an uninitialized area of memory, defined by a range (niebloid) | |
constructs objects by default-initialization in an uninitialized area of memory, defined by a start and count (niebloid) | |
constructs objects by value-initialization in an uninitialized area of memory, defined by a range (niebloid) | |
constructs objects by value-initialization in an uninitialized area of memory, defined by a start and a count (niebloid) | |
(C++20) |
destroys an object at a given address (niebloid) |
(C++20) |
destroys a range of objects (niebloid) |
(C++20) |
destroys a number of objects in a range (niebloid) |