Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help 
std::stable_partition(3)      C++ Standard Libary     std::stable_partition(3)

NAME
       std::stable_partition - std::stable_partition

Synopsis
	  Defined in header <algorithm>
	  template< class BidirIt, class UnaryPredicate	>
	  BidirIt    stable_partition(	  BidirIt    first,    BidirIt	 last,
       (1)
	  UnaryPredicate p );
	  template< class ExecutionPolicy, class BidirIt, class
	  UnaryPredicate						     >
       (2) (since C++17)
	  BidirIt stable_partition( ExecutionPolicy&& policy, BidirIt first,
	  BidirIt last,	UnaryPredicate p );

	  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>>
	  (until C++20)
	  std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>>
	  (since C++20)	is true.

Parameters
	  first, last -	 the range of elements to reorder
	  policy      -	 the execution policy to use. See execution policy for
       details.
			 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 v
	  p	       -   of  type (possibly const) VT, where VT is the value
       type of BidirIt,
			 regardless of value category, and must	not modify  v.
       Thus, a
			 parameter type	of VT&is not allowed
			 ,  nor	 is VT unless for VT a move is equivalent to a
       copy
			 (since	C++11).

Type requirements
	  -
	  BidirIt must meet the	requirements of	ValueSwappable and
	  LegacyBidirectionalIterator.
	  -
	  The type of dereferenced BidirIt must	meet the requirements of Move-
       Assignable and
	  MoveConstructible.
	  -
	  UnaryPredicate must meet the requirements of Predicate.

Return value
	  Iterator to the first	element	of the second group

Complexity
	  Given	N = std::distance(first, last),

	  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 predicate

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::termi-
       nate is called.
	      For any other ExecutionPolicy, 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	 allo-
       cation fails, the
	  less efficient algorithm is chosen.

	  Implementations  in  libc++ and libstdc++ also accept	ranges denoted
       by
	  LegacyForwardIterators as an extension.

Example
       // Run this code

	#include <iostream>
	#include <algorithm>
	#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

See also
	  partition		   divides a range of elements into two	groups
				   (function template)
	  ranges::stable_partition divides elements into two groups while pre-
       serving their
	  (C++20)		   relative order
				   (niebloid)

http://cppreference.com		  2022.07.31	      std::stable_partition(3)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=std::stable_partition&sektion=3&manpath=FreeBSD+Ports+15.0>

home | help