Defined in header `<algorithm>` | ||
---|---|---|

template< class BidirIt, class UnaryPredicate > BidirIt stable_partition( BidirIt first, BidirIt last, UnaryPredicate p ); | (1) | |

template< class ExecutionPolicy, class BidirIt, class UnaryPredicate > BidirIt stable_partition( ExecutionPolicy&& policy, BidirIt first, BidirIt last, UnaryPredicate p ); | (2) | (since C++17) |

1) Reorders the elements in the range

`[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.
2) Same as (1), but executed according to

`policy`

. This overload does not participate in overload resolution unless `std::is_execution_policy_v<std::decay_t<ExecutionPolicy>>`

is truefirst, 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 signature of the predicate function should be equivalent to the following:
The signature does not need to have |

Type requirements | ||

-`BidirIt` must meet the requirements of `ValueSwappable` and `BidirectionalIterator` . |
||

-The type of dereferenced `BidirIt` must meet the requirements of `MoveAssignable` and `MoveConstructible` . |
||

-`UnaryPredicate` must meet the requirements of `Predicate` . |

Iterator to the first element of the second group.

Given `N = last - first`

.

1) Exactly

`N`

applications of the predicate and `O(N)`

swaps if there is enough extra memory. If memory is insufficient, at most `N log N`

swaps.
2)

`O(N log N)`

swaps and `O(N)`

applications of the predicateThe 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 three standard policies,`std::terminate`

is called. For any other`ExecutionPolicy`

, the behavior is implementation-defined. - If the algorithm fails to allocate memory,
`std::bad_alloc`

is thrown.

This function attempts to allocate a temporary buffer. If the allocation fails, the less efficient algorithm is chosen.

#include <iostream> #include <algorithm> #include <vector> int main() { std::vector<int> v{0, 0, 3, 0, 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 0 0

divides a range of elements into two groups (function template) |

© cppreference.com

Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.

http://en.cppreference.com/w/cpp/algorithm/stable_partition