Namespaces
Variants

std:: is_partitioned

From cppreference.net
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)
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
is_partitioned
(C++11)

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
Permutation operations
C library
Numeric operations
Operations on uninitialized memory
Défini dans l'en-tête <algorithm>
template < class InputIt, class UnaryPred >
bool is_partitioned ( InputIt first, InputIt last, UnaryPred p ) ;
(1) (depuis C++11)
(constexpr depuis C++20)
template < class ExecutionPolicy, class ForwardIt, class UnaryPred >

bool is_partitioned ( ExecutionPolicy && policy,

ForwardIt first, ForwardIt last, UnaryPred p ) ;
(2) (depuis C++17)
1) Vérifie si [ first , last ) est partitionné par le prédicat p : tous les éléments satisfaisant p apparaissent avant tous les éléments qui ne le satisfont pas.
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)

Table des matières

Paramètres

first, last - la paire d'itérateurs définissant la plage d'éléments à examiner
policy - la politique d'exécution à utiliser
p - prédicat unaire qui retourne ​ true pour les éléments attendus au début de la plage.

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 InputIt , 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 est équivalent à une copie (depuis C++11) . ​

Exigences de type
-
InputIt doit satisfaire aux exigences de LegacyInputIterator .
-
ForwardIt doit satisfaire aux exigences de LegacyForwardIterator . et son type de valeur doit être convertible vers le type de paramètre de UnaryPred .
-
UnaryPred doit satisfaire aux exigences de Predicate .

Valeur de retour

true si les éléments e de [ first , last ) sont partitionnés par rapport à l'expression p ( e ) . false sinon.

Complexité

Au plus std:: distance ( first, last ) applications de p .

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ée.

Implémentation possible

template<class InputIt, class UnaryPred>
bool is_partitioned(InputIt first, InputIt last, UnaryPred p)
{
    for (; first != last; ++first)
        if (!p(*first))
            break;
    for (; first != last; ++first)
        if (p(*first))
            return false;
    return true;
}

Exemple

#include <algorithm>
#include <array>
#include <iostream>
int main()
{
    std::array<int, 9> v {1, 2, 3, 4, 5, 6, 7, 8, 9};
    auto is_even = [](int i) { return i % 2 == 0; };
    std::cout.setf(std::ios_base::boolalpha);
    std::cout << std::is_partitioned(v.begin(), v.end(), is_even) << ' ';
    std::partition(v.begin(), v.end(), is_even);
    std::cout << std::is_partitioned(v.begin(), v.end(), is_even) << ' ';
    std::reverse(v.begin(), v.end());
    std::cout << std::is_partitioned(v.cbegin(), v.cend(), is_even) << ' ';
    std::cout << std::is_partitioned(v.crbegin(), v.crend(), is_even) << '\n';
}

Sortie :

false true false true

Voir aussi

divise une plage d'éléments en deux groupes
(modèle de fonction)
localise le point de partition d'une plage partitionnée
(modèle de fonction)
détermine si la plage est partitionnée par le prédicat donné
(objet fonction algorithme)