Namespaces
Variants

std:: stable_partition

From cppreference.net
C++
Algorithm library
Constrained algorithms and algorithms on ranges (C++20)
Constrained algorithms, e.g. ranges::copy , ranges::sort , ...
Execution policies (C++17)
Non-modifying sequence operations
Batch operations
(C++17)
Search operations
Modifying sequence operations
Copy operations
(C++11)
(C++11)
(C++11)
Swap operations
Transformation operations
Generation operations
Removing operations
Order-changing operations
(until C++17) (C++11)
(C++20) (C++20)
Sampling operations
(C++17)

Sorting and related operations
Partitioning operations
(C++11)
stable_partition
Sorting operations
Binary search operations
(on partitioned ranges)
Set operations (on sorted ranges)
Merge operations (on sorted ranges)
Heap operations
Minimum/maximum operations
Lexicographical comparison operations
(C++20)
Permutation operations
C library
Numeric operations
Operations on uninitialized memory
Défini dans l'en-tête <algorithm>
template < class BidirIt, class UnaryPred >
BidirIt stable_partition ( BidirIt first, BidirIt last, UnaryPred p ) ;
(1) (constexpr depuis C++26)
template < class ExecutionPolicy, class BidirIt, class UnaryPred >

BidirIt stable_partition ( ExecutionPolicy && policy,

BidirIt first, BidirIt last, UnaryPred p ) ;
(2) (depuis C++17)
1) Réorganise les éléments dans la plage [ first , last ) de telle sorte que tous les éléments pour lesquels le prédicat p renvoie true précèdent les éléments pour lesquels le prédicat p renvoie false . L'ordre relatif des éléments est préservé.
2) Identique à (1) , mais exécuté selon la policy .
Cette surcharge participe à la résolution de surcharge seulement si toutes les conditions suivantes sont satisfaites :

std:: is_execution_policy_v < std:: decay_t < ExecutionPolicy >> est true .

(jusqu'à C++20)

std:: is_execution_policy_v < std:: remove_cvref_t < ExecutionPolicy >> est true .

(depuis C++20)

Si l'une des conditions suivantes est satisfaite, le comportement est indéfini :

(jusqu'à C++11)
(depuis C++11)

Table des matières

Paramètres

first, last - la paire d'itérateurs définissant l'intervalle des éléments à réorganiser
policy - la politique d'exécution à utiliser
p - prédicat unaire qui renvoie ​ true si l'élément doit être ordonné avant les autres éléments.

L'expression p ( v ) doit être convertible en bool pour chaque argument v de type (éventuellement const) VT , où VT est le type de valeur de BidirIt , indépendamment de la catégorie de valeur , et ne doit pas modifier v . Ainsi, un type de paramètre VT & n'est pas autorisé , pas plus que VT sauf si pour VT un déplacement équivaut à une copie (depuis C++11) . ​

Exigences de type
-
BidirIt doit satisfaire aux exigences de LegacyBidirectionalIterator .
-
UnaryPred doit satisfaire aux exigences de Predicate .

Valeur de retour

Itérateur vers le premier élément du deuxième groupe.

Complexité

Étant donné N comme std:: distance ( first, last ) :

1) Exactement N applications de p .
O(N) échanges s'il y a suffisamment de mémoire supplémentaire, sinon au plus N⋅log 2 (N) échanges.
2) O(N) applications de p .
N⋅log(N) échanges.

Exceptions

La surcharge avec un paramètre de modèle nommé ExecutionPolicy signale les erreurs comme suit :

  • Si l'exécution d'une fonction invoquée dans le cadre de l'algorithme lève une exception et que ExecutionPolicy fait partie des politiques standard , std::terminate est appelé. Pour tout autre ExecutionPolicy , le comportement est défini par l'implémentation.
  • Si l'algorithme ne parvient pas à allouer de la mémoire, std::bad_alloc est levé.

Notes

Cette fonction tente d'allouer un tampon temporaire. Si l'allocation échoue, l'algorithme moins efficace est choisi.

Les implémentations dans libc++ et libstdc++ acceptent également les plages dénotées par des LegacyForwardIterator s comme extension.

Macro de test de fonctionnalité Valeur Std Fonctionnalité
__cpp_lib_constexpr_algorithms 202306L (C++26) constexpr tri stable ( 1 )

Exemple

Exécuter ce code 
#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';
}

Sortie : 

3 2 4 5 7 0 0 -1 0

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR Appliqué à Comportement tel que publié Comportement correct
LWG 2150 C++98 std::stable_partition n'était requis que pour placer un
élément satisfaisant p avant un élément ne satisfaisant pas p 		corrigé l'exigence
requise

Voir aussi

divise une plage d'éléments en deux groupes
(modèle de fonction)
(C++20)
divise les éléments en deux groupes en préservant leur ordre relatif
(objet fonction algorithme)