| Defined in header <algorithm>
|
||
| Call signature |
||
| template< std::input_iterator I1, std::sentinel_for<I1> S1, std::random_access_iterator I2, std::sentinel_for<I2> S2, class Comp = ranges::less, class Proj1 = std::identity, class Proj2 = std::identity > requires std::indirectly_copyable<I1, I2> && std::sortable<I2, Comp, Proj2> && std::indirect_strict_weak_order<Comp, std::projected<I1, Proj1>, std::projected<I2, Proj2>> constexpr partial_sort_copy_result<I1, I2> partial_sort_copy( I1 first, S1 last, I2 result_first, S2 result_last, Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {} ); |
(1) | (since C++20) |
| template< ranges::input_range R1, ranges::random_access_range R2, class Comp = ranges::less, class Proj1 = std::identity, class Proj2 = std::identity > requires std::indirectly_copyable<ranges::iterator_t<R1>, ranges::iterator_t<R2>> && std::sortable<ranges::iterator_t<R2>, Comp, Proj2> && std::indirect_strict_weak_order<Comp, std::projected<ranges::iterator_t<R1>, Proj1>, std::projected<ranges::iterator_t<R2>, Proj2>> constexpr partial_sort_copy_result<ranges::borrowed_iterator_t<R1>, ranges::borrowed_iterator_t<R2>> partial_sort_copy( R1&& r, R2&& result_r, Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {} ); |
(2) | (since C++20) |
| Helper types |
||
| template< class I, class O > using partial_sort_copy_result = ranges::in_out_result<I, O>; |
(3) | (since C++20) |
Copies the first N elements from the source range [first, last), as if it was partially sorted with respect to comp and proj1, into the destination range [result_first, result_first + N), where N = min(L₁, L₂), L₁ is equal to ranges::distance(first, last), and L₂ is equal to ranges::distance(result_first, result_last).
The order of equal elements is not guaranteed to be preserved.
proj1, and the destination elements are projected using the function object proj2.r as the source range and result_r as the destination range, as if using ranges::begin(r) as first, ranges::end(r) as last, ranges::begin(result_r) as result_first, and ranges::end(result_r) as result_last.The function-like entities described on this page are algorithm function objects (informally known as niebloids), that is:
- Explicit template argument lists cannot be specified when calling any of them.
- None of them are visible to argument-dependent lookup.
- When any of them are found by normal unqualified lookup as the name to the left of the function-call operator, argument-dependent lookup is inhibited.
Parameters
| first, last | - | iterator-sentinel defining the source range to copy from |
| r | - | the source range to copy from |
| result_first, result_last | - | iterator-sentinel defining the destination range |
| result_r | - | the destination range |
| comp | - | comparison to apply to the projected elements |
| proj1 | - | projection to apply to the elements of source range |
| proj2 | - | projection to apply to the elements of destination range |
Return value
An object equal to {last, result_first + N}.
Complexity
At most L₁•log(N) comparisons and 2•L₁•log(N) projections.
Possible implementation
|
Example
#include <algorithm>
#include <forward_list>
#include <functional>
#include <iostream>
#include <ranges>
#include <string_view>
#include <vector>
void print(std::string_view rem, std::ranges::input_range auto const& v)
{
for (std::cout << rem; const auto& e : v)
std::cout << e << ' ';
std::cout << '\n';
}
int main()
{
const std::forward_list source{4, 2, 5, 1, 3};
print("Write to the smaller vector in ascending order: ", "");
std::vector dest1{10, 11, 12};
print("const source list: ", source);
print("destination range: ", dest1);
std::ranges::partial_sort_copy(source, dest1);
print("partial_sort_copy: ", dest1);
print("Write to the larger vector in descending order:", "");
std::vector dest2{10, 11, 12, 13, 14, 15, 16};
print("const source list: ", source);
print("destination range: ", dest2);
std::ranges::partial_sort_copy(source, dest2, std::greater{});
print("partial_sort_copy: ", dest2);
}Write to the smaller vector in ascending order:
const source list: 4 2 5 1 3
destination range: 10 11 12
partial_sort_copy: 1 2 3
Write to the larger vector in descending order:
const source list: 4 2 5 1 3
destination range: 10 11 12 13 14 15 16
partial_sort_copy: 5 4 3 2 1 15 16See also
| (C++20) |
sorts the first N elements of a range (algorithm function object) |
| (C++20) |
sorts a range into ascending order (algorithm function object) |
| (C++20) |
sorts a range of elements while preserving order between equal elements (algorithm function object) |
| (C++20) |
turns a max heap into a range of elements sorted in ascending order (algorithm function object) |
| (C++20) |
creates a max heap out of a range of elements (algorithm function object) |
| (C++20) |
adds an element to a max heap (algorithm function object) |
| (C++20) |
removes the largest element from a max heap (algorithm function object) |
| copies and partially sorts a range of elements (function template) |
Content from this page on cppreference.com, licensed under CC-BY-SA 3.0 and GFDL. Modified: restyled, site navigation removed, code windows added. Offline snapshot of 9 February 2025.