function template
<algorithm>

std::stable_partition

template <class BidirectionalIterator, class UnaryPredicate>
BidirectionalIterator stable_partition (BidirectionalIterator first,
BidirectionalIterator last,
UnaryPredicate pred);
Partition range in two - stable ordering
Rearranges the elements in the range [first,last), in such a way that all the elements for which pred returns true precede all those for which it returns false, and, unlike function partition, the relative order of elements within each group is preserved.

This is generally implemented using an internal temporary buffer.

Parameters

first, last
Bidirectional iterators to the initial and final positions of the sequence to partition. The range used is [first,last), which contains all the elements between first and last, including the element pointed by first but not the element pointed by last.
BidirectionalIterator shall point to a type for which swap is defined (and swaps the value of its arguments) and which is both move-constructible and move-assignable.
pred
Unary function that accepts an element in the range as argument, and returns a value convertible to bool. The value returned indicates whether the element is to be placed before (if true, it is placed before all the elements for which it returns false).
The function shall not modify its argument.
This can either be a function pointer or a function object.

Return value

An iterator that points to the first element of the second group of elements (those for which pred returns false), or last if this group is empty.

Example

 1234567891011121314151617181920212223242526272829 // stable_partition example #include // std::cout #include // std::stable_partition #include // std::vector bool IsOdd (int i) { return (i%2)==1; } int main () { std::vector myvector; // set some values: for (int i=1; i<10; ++i) myvector.push_back(i); // 1 2 3 4 5 6 7 8 9 std::vector::iterator bound; bound = std::stable_partition (myvector.begin(), myvector.end(), IsOdd); // print out content: std::cout << "odd elements:"; for (std::vector::iterator it=myvector.begin(); it!=bound; ++it) std::cout << ' ' << *it; std::cout << '\n'; std::cout << "even elements:"; for (std::vector::iterator it=bound; it!=myvector.end(); ++it) std::cout << ' ' << *it; std::cout << '\n'; return 0; }

Output:
 odd elements: 1 3 5 7 9 even elements: 2 4 6 8

Complexity

If enough extra memory is available, linear in the distance between first and last: Applies pred exactly once to each element, and performs up to that many element moves.
Otherwise, up to linearithmic: Performs up to N*log(N) element swaps (where N is the distance above). It also applies pred exactly once to each element.

Data races

The objects in the range [first,last) are modified.

Exceptions

Throws if any of the element comparisons, the element swaps (or moves) or the operations on iterators throws.
Note that invalid arguments cause undefined behavior.