Difference between revisions of "cpp/algorithm/ranges"

Latest revision as of 09:31, 20 May 2024

C++20 provides constrained versions of most algorithms in the namespace std::ranges. In these algorithms, a range can be specified as either an iterator-sentinel pair or as a single range argument, and projections and pointer-to-member callables are supported. Additionally, the return types of most algorithms have been changed to return all potentially useful information computed during the execution of the algorithm.

Defined in header `<algorithm>`
Defined in namespace `std::ranges`
Non-modifying sequence operations
ranges::all_ofranges::any_ofranges::none_of (C++20)(C++20)(C++20)	checks if a predicate is true for all, any or none of the elements in a range (niebloid)[edit]
ranges::for_each (C++20)	applies a function to a range of elements (niebloid)[edit]
ranges::for_each_n (C++20)	applies a function object to the first N elements of a sequence (niebloid)[edit]
ranges::countranges::count_if (C++20)(C++20)	returns the number of elements satisfying specific criteria (niebloid)[edit]
ranges::mismatch (C++20)	finds the first position where two ranges differ (niebloid)[edit]
ranges::equal (C++20)	determines if two sets of elements are the same (niebloid)[edit]
ranges::lexicographical_compare (C++20)	returns true if one range is lexicographically less than another (niebloid)[edit]
ranges::findranges::find_ifranges::find_if_not (C++20)(C++20)(C++20)	finds the first element satisfying specific criteria (niebloid)[edit]
ranges::find_lastranges::find_last_ifranges::find_last_if_not (C++23)(C++23)(C++23)	finds the last element satisfying specific criteria (niebloid)[edit]
ranges::find_end (C++20)	finds the last sequence of elements in a certain range (niebloid)[edit]
ranges::find_first_of (C++20)	searches for any one of a set of elements (niebloid)[edit]
ranges::adjacent_find (C++20)	finds the first two adjacent items that are equal (or satisfy a given predicate) (niebloid)[edit]
ranges::search (C++20)	searches for the first occurrence of a range of elements (niebloid)[edit]
ranges::search_n (C++20)	searches for the first occurrence of a number consecutive copies of an element in a range (niebloid)[edit]
ranges::containsranges::contains_subrange (C++23)(C++23)	checks if the range contains the given element or subrange (niebloid)[edit]
ranges::starts_with (C++23)	checks whether a range starts with another range (niebloid)[edit]
ranges::ends_with (C++23)	checks whether a range ends with another range (niebloid)[edit]
Modifying sequence operations
ranges::copyranges::copy_if (C++20)(C++20)	copies a range of elements to a new location (niebloid)[edit]
ranges::copy_n (C++20)	copies a number of elements to a new location (niebloid)[edit]
ranges::copy_backward (C++20)	copies a range of elements in backwards order (niebloid)[edit]
ranges::move (C++20)	moves a range of elements to a new location (niebloid)[edit]
ranges::move_backward (C++20)	moves a range of elements to a new location in backwards order (niebloid)[edit]
ranges::fill (C++20)	assigns a range of elements a certain value (niebloid)[edit]
ranges::fill_n (C++20)	assigns a value to a number of elements (niebloid)[edit]
ranges::transform (C++20)	applies a function to a range of elements (niebloid)[edit]
ranges::generate (C++20)	saves the result of a function in a range (niebloid)[edit]
ranges::generate_n (C++20)	saves the result of N applications of a function (niebloid)[edit]
ranges::removeranges::remove_if (C++20)(C++20)	removes elements satisfying specific criteria (niebloid)[edit]
ranges::remove_copyranges::remove_copy_if (C++20)(C++20)	copies a range of elements omitting those that satisfy specific criteria (niebloid)[edit]
ranges::replaceranges::replace_if (C++20)(C++20)	replaces all values satisfying specific criteria with another value (niebloid)[edit]
ranges::replace_copyranges::replace_copy_if (C++20)(C++20)	copies a range, replacing elements satisfying specific criteria with another value (niebloid)[edit]
ranges::swap_ranges (C++20)	swaps two ranges of elements (niebloid)[edit]
ranges::reverse (C++20)	reverses the order of elements in a range (niebloid)[edit]
ranges::reverse_copy (C++20)	creates a copy of a range that is reversed (niebloid)[edit]
ranges::rotate (C++20)	rotates the order of elements in a range (niebloid)[edit]
ranges::rotate_copy (C++20)	copies and rotate a range of elements (niebloid)[edit]
ranges::shuffle (C++20)	randomly re-orders elements in a range (niebloid)[edit]
ranges::shift_leftranges::shift_right (C++23)	shifts elements in a range (niebloid)[edit]
ranges::sample (C++20)	selects N random elements from a sequence (niebloid)[edit]
ranges::unique (C++20)	removes consecutive duplicate elements in a range (niebloid)[edit]
ranges::unique_copy (C++20)	creates a copy of some range of elements that contains no consecutive duplicates (niebloid)[edit]
Partitioning operations
ranges::is_partitioned (C++20)	determines if the range is partitioned by the given predicate (niebloid)[edit]
ranges::partition (C++20)	divides a range of elements into two groups (niebloid)[edit]
ranges::partition_copy (C++20)	copies a range dividing the elements into two groups (niebloid)[edit]
ranges::stable_partition (C++20)	divides elements into two groups while preserving their relative order (niebloid)[edit]
ranges::partition_point (C++20)	locates the partition point of a partitioned range (niebloid)[edit]
Sorting operations
ranges::is_sorted (C++20)	checks whether a range is sorted into ascending order (niebloid)[edit]
ranges::is_sorted_until (C++20)	finds the largest sorted subrange (niebloid)[edit]
ranges::sort (C++20)	sorts a range into ascending order (niebloid)[edit]
ranges::partial_sort (C++20)	sorts the first N elements of a range (niebloid)[edit]
ranges::partial_sort_copy (C++20)	copies and partially sorts a range of elements (niebloid)[edit]
ranges::stable_sort (C++20)	sorts a range of elements while preserving order between equal elements (niebloid)[edit]
ranges::nth_element (C++20)	partially sorts the given range making sure that it is partitioned by the given element (niebloid)[edit]
Binary search operations (on sorted ranges)
ranges::lower_bound (C++20)	returns an iterator to the first element not less than the given value (niebloid)[edit]
ranges::upper_bound (C++20)	returns an iterator to the first element greater than a certain value (niebloid)[edit]
ranges::binary_search (C++20)	determines if an element exists in a partially-ordered range (niebloid)[edit]
ranges::equal_range (C++20)	returns range of elements matching a specific key (niebloid)[edit]
Set operations (on sorted ranges)
ranges::merge (C++20)	merges two sorted ranges (niebloid)[edit]
ranges::inplace_merge (C++20)	merges two ordered ranges in-place (niebloid)[edit]
ranges::includes (C++20)	returns true if one sequence is a subsequence of another (niebloid)[edit]
ranges::set_difference (C++20)	computes the difference between two sets (niebloid)[edit]
ranges::set_intersection (C++20)	computes the intersection of two sets (niebloid)[edit]
ranges::set_symmetric_difference (C++20)	computes the symmetric difference between two sets (niebloid)[edit]
ranges::set_union (C++20)	computes the union of two sets (niebloid)[edit]
Heap operations
ranges::is_heap (C++20)	checks if the given range is a max heap (niebloid)[edit]
ranges::is_heap_until (C++20)	finds the largest subrange that is a max heap (niebloid)[edit]
ranges::make_heap (C++20)	creates a max heap out of a range of elements (niebloid)[edit]
ranges::push_heap (C++20)	adds an element to a max heap (niebloid)[edit]
ranges::pop_heap (C++20)	removes the largest element from a max heap (niebloid)[edit]
ranges::sort_heap (C++20)	turns a max heap into a range of elements sorted in ascending order (niebloid)[edit]
Minimum/maximum operations
ranges::max (C++20)	returns the greater of the given values (niebloid)[edit]
ranges::max_element (C++20)	returns the largest element in a range (niebloid)[edit]
ranges::min (C++20)	returns the smaller of the given values (niebloid)[edit]
ranges::min_element (C++20)	returns the smallest element in a range (niebloid)[edit]
ranges::minmax (C++20)	returns the smaller and larger of two elements (niebloid)[edit]
ranges::minmax_element (C++20)	returns the smallest and the largest elements in a range (niebloid)[edit]
ranges::clamp (C++20)	clamps a value between a pair of boundary values (niebloid)[edit]
Permutation operations
ranges::is_permutation (C++20)	determines if a sequence is a permutation of another sequence (niebloid)[edit]
ranges::next_permutation (C++20)	generates the next greater lexicographic permutation of a range of elements (niebloid)[edit]
ranges::prev_permutation (C++20)	generates the next smaller lexicographic permutation of a range of elements (niebloid)[edit]

[edit] Constrained numeric operations

Defined in header `<numeric>`
Defined in namespace `std::ranges`
ranges::iota (C++23)	fills a range with successive increments of the starting value (niebloid)[edit]

[edit] Constrained fold operations

Defined in header `<algorithm>`
Defined in namespace `std::ranges`
ranges::fold_left (C++23)	left-folds a range of elements (niebloid)[edit]
ranges::fold_left_first (C++23)	left-folds a range of elements using the first element as an initial value (niebloid)[edit]
ranges::fold_right (C++23)	right-folds a range of elements (niebloid)[edit]
ranges::fold_right_last (C++23)	right-folds a range of elements using the last element as an initial value (niebloid)[edit]
ranges::fold_left_with_iter (C++23)	left-folds a range of elements, and returns a pair (iterator, value) (niebloid)[edit]
ranges::fold_left_first_with_iter (C++23)	left-folds a range of elements using the first element as an initial value, and returns a pair (iterator, optional) (niebloid)[edit]

[edit] Constrained uninitialized memory algorithms

Defined in header `<memory>`
Defined in namespace `std::ranges`
ranges::uninitialized_copy (C++20)	copies a range of objects to an uninitialized area of memory (niebloid)[edit]
ranges::uninitialized_copy_n (C++20)	copies a number of objects to an uninitialized area of memory (niebloid)[edit]
ranges::uninitialized_fill (C++20)	copies an object to an uninitialized area of memory, defined by a range (niebloid)[edit]
ranges::uninitialized_fill_n (C++20)	copies an object to an uninitialized area of memory, defined by a start and a count (niebloid)[edit]
ranges::uninitialized_move (C++20)	moves a range of objects to an uninitialized area of memory (niebloid)[edit]
ranges::uninitialized_move_n (C++20)	moves a number of objects to an uninitialized area of memory (niebloid)[edit]
ranges::uninitialized_default_construct (C++20)	constructs objects by default-initialization in an uninitialized area of memory, defined by a range (niebloid)[edit]
ranges::uninitialized_default_construct_n (C++20)	constructs objects by default-initialization in an uninitialized area of memory, defined by a start and count (niebloid)[edit]
ranges::uninitialized_value_construct (C++20)	constructs objects by value-initialization in an uninitialized area of memory, defined by a range (niebloid)[edit]
ranges::uninitialized_value_construct_n (C++20)	constructs objects by value-initialization in an uninitialized area of memory, defined by a start and a count (niebloid)[edit]
ranges::destroy (C++20)	destroys a range of objects (niebloid)[edit]
ranges::destroy_n (C++20)	destroys a number of objects in a range (niebloid)[edit]
ranges::destroy_at (C++20)	destroys an object at a given address (niebloid)[edit]
ranges::construct_at (C++20)	creates an object at a given address (niebloid)[edit]

[edit] Constrained random number algorithms

Defined in header `<random>`
Defined in namespace `std::ranges`
ranges::generate_random (C++26)	fills a range with random numbers from a uniform random bit generator (niebloid)[edit]

[edit] Return types

Defined in header `<algorithm>`
Defined in namespace `std::ranges`
ranges::in_fun_result (C++20)	provides a way to store an iterator and a function object as a single unit (class template) [edit]
ranges::in_in_result (C++20)	provides a way to store two iterators as a single unit (class template) [edit]
ranges::in_out_result (C++20)	provides a way to store two iterators as a single unit (class template) [edit]
ranges::in_in_out_result (C++20)	provides a way to store three iterators as a single unit (class template) [edit]
ranges::in_out_out_result (C++20)	provides a way to store three iterators as a single unit (class template) [edit]
ranges::min_max_result (C++20)	provides a way to store two objects or references of the same type as a single unit (class template) [edit]
ranges::in_found_result (C++20)	provides a way to store an iterator and a boolean flag as a single unit (class template) [edit]
ranges::in_value_result (C++23)	provides a way to store an iterator and a value as a single unit (class template) [edit]
ranges::out_value_result (C++23)	provides a way to store an iterator and a value as a single unit (class template) [edit]

[edit] Notes

Feature-test macro	Value	Std	Feature
`__cpp_lib_algorithm_default_value_type`	202403L	(C++26)	List-initialization for algorithms
`__cpp_lib_ranges`	201911L	(C++20)	Ranges library and constrained algorithms
`__cpp_lib_ranges_contains`	202207L	(C++23)	std::ranges::contains
`__cpp_lib_ranges_find_last`	202207L	(C++23)	std::ranges::find_last
`__cpp_lib_ranges_fold`	202207L	(C++23)	`std::ranges` fold algorithms
`__cpp_lib_ranges_iota`	202202L	(C++23)	std::ranges::iota
`__cpp_lib_ranges_starts_ends_with`	202106L	(C++23)	std::ranges::starts_with, std::ranges::ends_with
`__cpp_lib_shift`	201806L	(C++20)	std::shift_left, std::shift_right
`__cpp_lib_shift`	202202L	(C++23)	std::ranges::shift_left, std::ranges::shift_right
`__cpp_lib_ranges_generate_random`	202403L	(C++26)	std::ranges::generate_random

@@ Line 1: / Line 1: @@
-{{title| Range algorithms {{mark since c++20}}}}
+{{title|Constrained algorithms {{mark since c++20}}}}
 {{cpp/algorithm/ranges/navbar}}
+C++20 provides [[cpp/language/constraints|constrained]] versions of most algorithms in the namespace {{tt|std::ranges}}. In these algorithms, a range can be specified as either an [[cpp/iterator/input_or_output_iterator|iterator]]-[[cpp/iterator/sentinel_for|sentinel]] pair or as a single {{lconcept|range}} argument, and projections and pointer-to-member callables are supported. Additionally, the [[cpp/algorithm/ranges#Return types|return types]] of most algorithms have been changed to return all potentially useful information computed during the execution of the algorithm.
+===Constrained algorithms===
 {{dsc begin}}
-{{dsc header | algorithm}}
+{{dsc header|algorithm}}
-{{dsc namespace | std::ranges}}
+{{dsc namespace|std::ranges}}
-{{dsc h2 | Non-modifying sequence operations}}
+{{dsc h2|Non-modifying sequence operations}}
-{{dsc inc | cpp/algorithm/ranges/dsc all_any_none_of}}
+{{dsc inc|cpp/algorithm/ranges/dsc all_any_none_of}}
-{{dsc inc | cpp/algorithm/ranges/dsc for_each}}
+{{dsc inc|cpp/algorithm/ranges/dsc for_each}}
-{{dsc inc | cpp/algorithm/ranges/dsc count}}
+{{dsc inc|cpp/algorithm/ranges/dsc for_each_n}}
-{{dsc inc | cpp/algorithm/ranges/dsc mismatch}}
+{{dsc inc|cpp/algorithm/ranges/dsc count}}
-{{dsc inc | cpp/algorithm/ranges/dsc equal}}
+{{dsc inc|cpp/algorithm/ranges/dsc mismatch}}
-{{dsc inc | cpp/algorithm/ranges/dsc lexicographical_compare}}
+{{dsc inc|cpp/algorithm/ranges/dsc equal}}
-{{dsc inc | cpp/algorithm/ranges/dsc find}}
+{{dsc inc|cpp/algorithm/ranges/dsc lexicographical_compare}}
-{{dsc inc | cpp/algorithm/ranges/dsc find_end}}
+{{dsc inc|cpp/algorithm/ranges/dsc find}}
-{{dsc inc | cpp/algorithm/ranges/dsc find_first_of}}
+{{dsc inc|cpp/algorithm/ranges/dsc find_last}}
-{{dsc inc | cpp/algorithm/ranges/dsc adjacent_find}}
+{{dsc inc|cpp/algorithm/ranges/dsc find_end}}
-{{dsc inc | cpp/algorithm/ranges/dsc search}}
+{{dsc inc|cpp/algorithm/ranges/dsc find_first_of}}
-{{dsc inc | cpp/algorithm/ranges/dsc search_n}}
+{{dsc inc|cpp/algorithm/ranges/dsc adjacent_find}}
+{{dsc inc|cpp/algorithm/ranges/dsc search}}
+{{dsc inc|cpp/algorithm/ranges/dsc search_n}}
+{{dsc inc|cpp/algorithm/ranges/dsc contains}}
+{{dsc inc|cpp/algorithm/ranges/dsc starts_with}}
+{{dsc inc|cpp/algorithm/ranges/dsc ends_with}}
-{{dsc h2 | Modifying sequence operations}}
+{{dsc h2|Modifying sequence operations}}
-{{dsc inc | cpp/algorithm/ranges/dsc copy}}
+{{dsc inc|cpp/algorithm/ranges/dsc copy}}
-{{dsc inc | cpp/algorithm/ranges/dsc copy_n}}
+{{dsc inc|cpp/algorithm/ranges/dsc copy_n}}
-{{dsc inc | cpp/algorithm/ranges/dsc copy_backward}}
+{{dsc inc|cpp/algorithm/ranges/dsc copy_backward}}
-{{dsc inc | cpp/algorithm/ranges/dsc move}}
+{{dsc inc|cpp/algorithm/ranges/dsc move}}
-{{dsc inc | cpp/algorithm/ranges/dsc move_backward}}
+{{dsc inc|cpp/algorithm/ranges/dsc move_backward}}
-{{dsc inc | cpp/algorithm/ranges/dsc fill}}
+{{dsc inc|cpp/algorithm/ranges/dsc fill}}
-{{dsc inc | cpp/algorithm/ranges/dsc fill_n}}
+{{dsc inc|cpp/algorithm/ranges/dsc fill_n}}
-{{dsc inc | cpp/algorithm/ranges/dsc transform}}
+{{dsc inc|cpp/algorithm/ranges/dsc transform}}
-{{dsc inc | cpp/algorithm/ranges/dsc generate}}
+{{dsc inc|cpp/algorithm/ranges/dsc generate}}
-{{dsc inc | cpp/algorithm/ranges/dsc generate_n}}
+{{dsc inc|cpp/algorithm/ranges/dsc generate_n}}
-{{dsc inc | cpp/algorithm/ranges/dsc remove}}
+{{dsc inc|cpp/algorithm/ranges/dsc remove}}
-{{dsc inc | cpp/algorithm/ranges/dsc remove_copy}}
+{{dsc inc|cpp/algorithm/ranges/dsc remove_copy}}
-{{dsc inc | cpp/algorithm/ranges/dsc replace}}
+{{dsc inc|cpp/algorithm/ranges/dsc replace}}
-{{dsc inc | cpp/algorithm/ranges/dsc replace_copy}}
+{{dsc inc|cpp/algorithm/ranges/dsc replace_copy}}
-{{dsc inc | cpp/algorithm/ranges/dsc swap_ranges}}
+{{dsc inc|cpp/algorithm/ranges/dsc swap_ranges}}
-{{dsc inc | cpp/algorithm/ranges/dsc reverse}}
+{{dsc inc|cpp/algorithm/ranges/dsc reverse}}
-{{dsc inc | cpp/algorithm/ranges/dsc reverse_copy}}
+{{dsc inc|cpp/algorithm/ranges/dsc reverse_copy}}
-{{dsc inc | cpp/algorithm/ranges/dsc rotate}}
+{{dsc inc|cpp/algorithm/ranges/dsc rotate}}
-{{dsc inc | cpp/algorithm/ranges/dsc rotate_copy}}
+{{dsc inc|cpp/algorithm/ranges/dsc rotate_copy}}
-{{dsc inc | cpp/algorithm/ranges/dsc shuffle}}
+{{dsc inc|cpp/algorithm/ranges/dsc shuffle}}
-{{dsc inc | cpp/algorithm/ranges/dsc unique}}
+{{dsc inc|cpp/algorithm/ranges/dsc shift}}
-{{dsc inc | cpp/algorithm/ranges/dsc unique_copy}}
+{{dsc inc|cpp/algorithm/ranges/dsc sample}}
+{{dsc inc|cpp/algorithm/ranges/dsc unique}}
+{{dsc inc|cpp/algorithm/ranges/dsc unique_copy}}
-{{dsc h2 | Partitioning operations}}
+{{dsc h2|Partitioning operations}}
-{{dsc inc | cpp/algorithm/ranges/dsc is_partitioned}}
+{{dsc inc|cpp/algorithm/ranges/dsc is_partitioned}}
-{{dsc inc | cpp/algorithm/ranges/dsc partition}}
+{{dsc inc|cpp/algorithm/ranges/dsc partition}}
-{{dsc inc | cpp/algorithm/ranges/dsc partition_copy}}
+{{dsc inc|cpp/algorithm/ranges/dsc partition_copy}}
-{{dsc inc | cpp/algorithm/ranges/dsc stable_partition}}
+{{dsc inc|cpp/algorithm/ranges/dsc stable_partition}}
-{{dsc inc | cpp/algorithm/ranges/dsc partition_point}}
+{{dsc inc|cpp/algorithm/ranges/dsc partition_point}}
-{{dsc h2 | Sorting operations}}
+{{dsc h2|Sorting operations}}
-{{dsc inc | cpp/algorithm/ranges/dsc is_sorted}}
+{{dsc inc|cpp/algorithm/ranges/dsc is_sorted}}
-{{dsc inc | cpp/algorithm/ranges/dsc is_sorted_until}}
+{{dsc inc|cpp/algorithm/ranges/dsc is_sorted_until}}
-{{dsc inc | cpp/algorithm/ranges/dsc sort}}
+{{dsc inc|cpp/algorithm/ranges/dsc sort}}
-{{dsc inc | cpp/algorithm/ranges/dsc partial_sort}}
+{{dsc inc|cpp/algorithm/ranges/dsc partial_sort}}
-{{dsc inc | cpp/algorithm/ranges/dsc partial_sort_copy}}
+{{dsc inc|cpp/algorithm/ranges/dsc partial_sort_copy}}
-{{dsc inc | cpp/algorithm/ranges/dsc stable_sort}}
+{{dsc inc|cpp/algorithm/ranges/dsc stable_sort}}
-{{dsc inc | cpp/algorithm/ranges/dsc nth_element}}
+{{dsc inc|cpp/algorithm/ranges/dsc nth_element}}
-{{dsc h2 | Binary search operations (on sorted ranges)}}
+{{dsc h2|Binary search operations (on sorted ranges)}}
-{{dsc inc | cpp/algorithm/ranges/dsc lower_bound}}
+{{dsc inc|cpp/algorithm/ranges/dsc lower_bound}}
-{{dsc inc | cpp/algorithm/ranges/dsc upper_bound}}
+{{dsc inc|cpp/algorithm/ranges/dsc upper_bound}}
-{{dsc inc | cpp/algorithm/ranges/dsc binary_search}}
+{{dsc inc|cpp/algorithm/ranges/dsc binary_search}}
-{{dsc inc | cpp/algorithm/ranges/dsc equal_range}}
+{{dsc inc|cpp/algorithm/ranges/dsc equal_range}}
-{{dsc h2 | Set operations (on sorted ranges)}}
+{{dsc h2|Set operations (on sorted ranges)}}
-{{dsc inc | cpp/algorithm/ranges/dsc merge}}
+{{dsc inc|cpp/algorithm/ranges/dsc merge}}
-{{dsc inc | cpp/algorithm/ranges/dsc inplace_merge}}
+{{dsc inc|cpp/algorithm/ranges/dsc inplace_merge}}
-{{dsc inc | cpp/algorithm/ranges/dsc includes}}
+{{dsc inc|cpp/algorithm/ranges/dsc includes}}
-{{dsc inc | cpp/algorithm/ranges/dsc set_difference}}
+{{dsc inc|cpp/algorithm/ranges/dsc set_difference}}
-{{dsc inc | cpp/algorithm/ranges/dsc set_intersection}}
+{{dsc inc|cpp/algorithm/ranges/dsc set_intersection}}
-{{dsc inc | cpp/algorithm/ranges/dsc set_symmetric_difference}}
+{{dsc inc|cpp/algorithm/ranges/dsc set_symmetric_difference}}
-{{dsc inc | cpp/algorithm/ranges/dsc set_union}}
+{{dsc inc|cpp/algorithm/ranges/dsc set_union}}
-{{dsc h2 | Heap operations}}
+{{dsc h2|Heap operations}}
-{{dsc inc | cpp/algorithm/ranges/dsc is_heap}}
+{{dsc inc|cpp/algorithm/ranges/dsc is_heap}}
-{{dsc inc | cpp/algorithm/ranges/dsc is_heap_until}}
+{{dsc inc|cpp/algorithm/ranges/dsc is_heap_until}}
-{{dsc inc | cpp/algorithm/ranges/dsc make_heap}}
+{{dsc inc|cpp/algorithm/ranges/dsc make_heap}}
-{{dsc inc | cpp/algorithm/ranges/dsc push_heap}}
+{{dsc inc|cpp/algorithm/ranges/dsc push_heap}}
-{{dsc inc | cpp/algorithm/ranges/dsc pop_heap}}
+{{dsc inc|cpp/algorithm/ranges/dsc pop_heap}}
-{{dsc inc | cpp/algorithm/ranges/dsc sort_heap}}
+{{dsc inc|cpp/algorithm/ranges/dsc sort_heap}}
-{{dsc h2 | Minimum/maximum operations}}
+{{dsc h2|Minimum/maximum operations}}
-{{dsc inc | cpp/algorithm/ranges/dsc max}}
+{{dsc inc|cpp/algorithm/ranges/dsc max}}
-{{dsc inc | cpp/algorithm/ranges/dsc max_element}}
+{{dsc inc|cpp/algorithm/ranges/dsc max_element}}
-{{dsc inc | cpp/algorithm/ranges/dsc min}}
+{{dsc inc|cpp/algorithm/ranges/dsc min}}
-{{dsc inc | cpp/algorithm/ranges/dsc min_element}}
+{{dsc inc|cpp/algorithm/ranges/dsc min_element}}
-{{dsc inc | cpp/algorithm/ranges/dsc minmax}}
+{{dsc inc|cpp/algorithm/ranges/dsc minmax}}
-{{dsc inc | cpp/algorithm/ranges/dsc minmax_element}}
+{{dsc inc|cpp/algorithm/ranges/dsc minmax_element}}
+{{dsc inc|cpp/algorithm/ranges/dsc clamp}}
-{{dsc h2 | Permutation operations}}
+{{dsc h2|Permutation operations}}
-{{dsc inc | cpp/algorithm/ranges/dsc is_permutation}}
+{{dsc inc|cpp/algorithm/ranges/dsc is_permutation}}
-{{dsc inc | cpp/algorithm/ranges/dsc next_permutation}}
+{{dsc inc|cpp/algorithm/ranges/dsc next_permutation}}
-{{dsc inc | cpp/algorithm/ranges/dsc prev_permutation}}
+{{dsc inc|cpp/algorithm/ranges/dsc prev_permutation}}
 {{dsc end}}
+===Constrained numeric operations===
+{{dsc begin}}
+{{dsc header|numeric}}
+{{dsc namespace|std::ranges}}
+{{dsc inc|cpp/algorithm/ranges/dsc iota}}
+{{dsc end}}
+===Constrained fold operations===
+{{dsc begin}}
+{{dsc header|algorithm}}
+{{dsc namespace|std::ranges}}
+{{dsc inc|cpp/algorithm/ranges/dsc fold_left}}
+{{dsc inc|cpp/algorithm/ranges/dsc fold_left_first}}
+{{dsc inc|cpp/algorithm/ranges/dsc fold_right}}
+{{dsc inc|cpp/algorithm/ranges/dsc fold_right_last}}
+{{dsc inc|cpp/algorithm/ranges/dsc fold_left_with_iter}}
+{{dsc inc|cpp/algorithm/ranges/dsc fold_left_first_with_iter}}
+<!--
+{{dsc inc|cpp/algorithm/ranges/dsc accumulate}}
+{{dsc inc|cpp/algorithm/ranges/dsc inner_product}}
+{{dsc inc|cpp/algorithm/ranges/dsc adjacent_difference}}
+{{dsc inc|cpp/algorithm/ranges/dsc partial_sum}}
+{{dsc inc|cpp/algorithm/ranges/dsc reduce}}
+{{dsc inc|cpp/algorithm/ranges/dsc exclusive_scan}}
+{{dsc inc|cpp/algorithm/ranges/dsc inclusive_scan}}
+{{dsc inc|cpp/algorithm/ranges/dsc transform_reduce}}
+{{dsc inc|cpp/algorithm/ranges/dsc transform_exclusive_scan}}
+{{dsc inc|cpp/algorithm/ranges/dsc transform_inclusive_scan}}
+-->
+{{dsc end}}
+===Constrained uninitialized memory algorithms===
+{{dsc begin}}
+{{dsc header|memory}}
+{{dsc namespace|std::ranges}}
+{{dsc inc|cpp/memory/ranges/dsc uninitialized_copy}}
+{{dsc inc|cpp/memory/ranges/dsc uninitialized_copy_n}}
+{{dsc inc|cpp/memory/ranges/dsc uninitialized_fill}}
+{{dsc inc|cpp/memory/ranges/dsc uninitialized_fill_n}}
+{{dsc inc|cpp/memory/ranges/dsc uninitialized_move}}
+{{dsc inc|cpp/memory/ranges/dsc uninitialized_move_n}}
+{{dsc inc|cpp/memory/ranges/dsc uninitialized_default_construct}}
+{{dsc inc|cpp/memory/ranges/dsc uninitialized_default_construct_n}}
+{{dsc inc|cpp/memory/ranges/dsc uninitialized_value_construct}}
+{{dsc inc|cpp/memory/ranges/dsc uninitialized_value_construct_n}}
+{{dsc inc|cpp/memory/ranges/dsc destroy}}
+{{dsc inc|cpp/memory/ranges/dsc destroy_n}}
+{{dsc inc|cpp/memory/ranges/dsc destroy_at}}
+{{dsc inc|cpp/memory/ranges/dsc construct_at}}
+{{dsc end}}
+===Constrained random number algorithms===
+{{dsc begin}}
+{{dsc header|random}}
+{{dsc namespace|std::ranges}}
+{{dsc inc|cpp/algorithm/ranges/dsc generate_random}}
+{{dsc end}}
+===Return types===
+{{dsc begin}}
+{{dsc header|algorithm}}
+{{dsc namespace|std::ranges}}
+{{dsc inc|cpp/algorithm/ranges/return_types/dsc in_fun_result}}
+{{dsc inc|cpp/algorithm/ranges/return_types/dsc in_in_result}}
+{{dsc inc|cpp/algorithm/ranges/return_types/dsc in_out_result}}
+{{dsc inc|cpp/algorithm/ranges/return_types/dsc in_in_out_result}}
+{{dsc inc|cpp/algorithm/ranges/return_types/dsc in_out_out_result}}
+{{dsc inc|cpp/algorithm/ranges/return_types/dsc min_max_result}}
+{{dsc inc|cpp/algorithm/ranges/return_types/dsc in_found_result}}
+{{dsc inc|cpp/algorithm/ranges/return_types/dsc in_value_result}}
+{{dsc inc|cpp/algorithm/ranges/return_types/dsc out_value_result}}
+{{dsc end}}
+===Notes===
+{{ftm begin|std=1|sort=1|comment=1}}
+{{ftm|std=C++26|value=202403L|__cpp_lib_algorithm_default_value_type|[[cpp/language/list_initialization|List-initialization]] for algorithms}}
+{{ftm|std=C++20|value=201911L|__cpp_lib_ranges|[[cpp/ranges|Ranges library]] and [[#Top|constrained algorithms]]}}
+{{ftm|std=C++23|value=202207L|__cpp_lib_ranges_contains|{{lc|std::ranges::contains}}}}
+{{ftm|std=C++23|value=202207L|__cpp_lib_ranges_find_last|{{lc|std::ranges::find_last}}}}
+{{ftm|std=C++23|value=202207L|__cpp_lib_ranges_fold|{{tt|std::ranges}} [[#Constrained fold operations|fold algorithms]]}}
+{{ftm|std=C++23|value=202202L|__cpp_lib_ranges_iota|{{lc|std::ranges::iota}}}}
+{{ftm|std=C++23|value=202106L|__cpp_lib_ranges_starts_ends_with|{{lc|std::ranges::starts_with}}, {{lc|std::ranges::ends_with}}}}
+{{ftm|std=C++20|value=201806L|rowspan="2"|__cpp_lib_shift|{{lc|std::shift_left}}, {{lc|std::shift_right}}}}
+{{ftm|std=C++23|value=202202L|-|{{lc|std::ranges::shift_left}}, {{lc|std::ranges::shift_right}}}}
+{{ftm|std=C++26|value=202403L|__cpp_lib_ranges_generate_random|{{lc|std::ranges::generate_random}}}}
+{{ftm end}}
+{{langlinks|es|ja|ru|zh}}

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Metaprogramming library (C++11)
Diagnostics library
General utilities library
Strings library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Numerics library
Localizations library
Input/output library
Filesystem library (C++17)
Regular expressions library (C++11)
Concurrency support library (C++11)
Execution support library (C++26)
Technical specifications
Symbols index
External libraries

cppreference.com

Namespaces

Variants

Views

Actions

Difference between revisions of "cpp/algorithm/ranges"

Latest revision as of 09:31, 20 May 2024

Contents

[edit] Constrained algorithms

Non-modifying sequence operations

Modifying sequence operations

Partitioning operations

Sorting operations

Binary search operations (on sorted ranges)

Set operations (on sorted ranges)

Heap operations

Minimum/maximum operations

Permutation operations