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
. Relative order of the elements is preserved.
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. See execution policy for details. |
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
, the behavior is implementation-defined. - 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 LegacyForwardIterator s as an extension.
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 one
element 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) |