std::stable_partition
Defined in header <algorithm>
|
||
template
<
class BidirIt, class UnaryPred >
BidirIt stable_partition( BidirIt first, BidirIt last, UnaryPred p ) ; |
(1) | (constexpr since C++26) |
template
<
class ExecutionPolicy, class BidirIt, class UnaryPred >
BidirIt stable_partition( ExecutionPolicy&& policy, |
(2) | (since C++17) |
[
first
,
last
)
in such a way that all elements for which the predicate p returns true precede the elements for which predicate p returns false
std::is_execution_policy_v < std::decay_t <ExecutionPolicy>> is true |
(until C++20) |
std::is_execution_policy_v < std::remove_cvref_t <ExecutionPolicy>> is true |
(since C++20) |
If any of the following conditions is satisfied, the behavior is undefined:
|
(until C++11) |
|
(since C++11) |
Parameters
first, last | - | the range of elements to reorder |
policy | - | the execution policy to use |
p | - | unary predicate which returns true if the element should be ordered before other elements. The expression p(v) must be convertible to bool for every argument |
Type requirements | ||
-
BidirIt must meet the requirements of LegacyBidirectionalIterator
|
||
-
UnaryPred must meet the requirements of Predicate
|
Return value
Iterator to the first element of the second group.
Complexity
Given N as std::distance(first, last)
Exceptions
The overload with a template parameter named ExecutionPolicy
reports errors as follows:
- If execution of a function invoked as part of the algorithm throws an exception and
ExecutionPolicy
is one of the standard policies, std::terminate is called. For any otherExecutionPolicy
- If the algorithm fails to allocate memory, std::bad_alloc is thrown.
Notes
This function attempts to allocate a temporary buffer. If the allocation fails, the less efficient algorithm is chosen.
Implementations in libc++ and libstdc++ also accept ranges denoted by LegacyForwardIterators
Feature-test macro | Value | Std | Feature |
---|---|---|---|
__cpp_lib_constexpr_algorithms |
202306L |
(C++26) | constexpr stable sorting (1) |
Example
#include <algorithm> #include <iostream> #include <vector> int main() { std::vector<int> v{0, 0, 3, -1, 2, 4, 5, 0, 7}; std::stable_partition(v.begin(), v.end(), [](int n) { return n > 0; }); for (int n : v) std::cout << n << ' '; std::cout << '\n'; }
Output:
3 2 4 5 7 0 0 -1 0
Defect reports
The following behavior-changing defect reports were applied retroactively to previously published C++ standards.
DR | Applied to | Behavior as published | Correct behavior |
---|---|---|---|
LWG 2150 | C++98 |
std::stable_partition was only required to place oneelement satisfying p before one element not satisfying p |
corrected the requirement |
See also
divides a range of elements into two groups (function template) |
|
(C++20)
|
divides elements into two groups while preserving their relative order (algorithm function object) |