Namespaces
Variants

std:: is_sorted

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
Sorting operations
is_sorted
(C++11)
(C++11)

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 ForwardIt >
bool is_sorted ( ForwardIt first, ForwardIt last ) ;
(1) (depuis C++11)
(constexpr depuis C++20)
template < class ExecutionPolicy, class ForwardIt >

bool is_sorted ( ExecutionPolicy && policy,

ForwardIt first, ForwardIt last ) ;
(2) (depuis C++17)
template < class ForwardIt, class Compare >
bool is_sorted ( ForwardIt first, ForwardIt last, Compare comp ) ;
(3) (depuis C++11)
(constexpr depuis C++20)
template < class ExecutionPolicy, class ForwardIt, class Compare >

bool is_sorted ( ExecutionPolicy && policy,

ForwardIt first, ForwardIt last, Compare comp ) ;
(4) (depuis C++17)

Vérifie si les éléments dans la plage [ first , last ) sont triés en ordre non décroissant.

1) Vérifie si les éléments sont triés par rapport à operator < (jusqu'en C++20) std:: less { } (depuis C++20) .
3) Vérifie si les éléments sont triés par rapport à comp .
2,4) Identique à (1,3) , mais exécuté selon la policy .
Ces surcharges participent à 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 l'intervalle des éléments à examiner
policy - la politique d'exécution à utiliser
comp - objet fonction de comparaison (c'est-à-dire un objet qui satisfait aux exigences de Compare ) qui renvoie ​ true si le premier argument est inférieur à (c'est-à-dire est ordonné avant ) le second.

La signature de la fonction de comparaison doit être équivalente à ce qui suit :

bool cmp ( const Type1 & a, const Type2 & b ) ;

Bien que la signature n'ait pas besoin d'avoir const & , la fonction ne doit pas modifier les objets qui lui sont passés et doit pouvoir accepter toutes les valeurs du type (éventuellement const) Type1 et Type2 indépendamment de la catégorie de valeur (ainsi, Type1& n'est pas autorisé , pas plus que Type1 sauf si pour Type1 un déplacement équivaut à une copie (depuis C++11) ).
Les types Type1 et Type2 doivent être tels qu'un objet de type ForwardIt puisse être déréférencé puis implicitement converti vers les deux. ​

Exigences de type
-
ForwardIt doit satisfaire aux exigences de LegacyForwardIterator .
-
Compare doit satisfaire aux exigences de Compare .

Valeur de retour

true si les éléments de la plage sont triés en ordre non décroissant, false sinon.

Complexité

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

1,2) O(N) comparaisons en utilisant operator < (jusqu'à C++20) std:: less { } (depuis C++20) .
3,4) O(N) applications du comparateur comp .

Exceptions

Les surcharges avec un paramètre de modèle nommé ExecutionPolicy signalent 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

Voir également les implémentations dans libstdc++ et libc++ .


is_sorted (1) 
template<class ForwardIt>
bool is_sorted(ForwardIt first, ForwardIt last)
{
    return std::is_sorted_until(first, last) == last;
}
is_sorted (3) 
template<class ForwardIt, class Compare>
bool is_sorted(ForwardIt first, ForwardIt last, Compare comp)
{
    return std::is_sorted_until(first, last, comp) == last;
}

Notes

std::is_sorted renvoie true pour les plages vides et les plages de longueur un.

Exemple

Exécuter ce code 
#include <algorithm>
#include <cassert>
#include <functional>
#include <iterator>
#include <vector>
int main()
{
    std::vector<int> v;
    assert(std::is_sorted(v.cbegin(), v.cend()) && "une plage vide est toujours triée");
    v.push_back(42);
    assert(std::is_sorted(v.cbegin(), v.cend()) && "une plage de taille 1 est toujours triée");
    int data[] = {3, 1, 4, 1, 5};
    assert(not std::is_sorted(std::begin(data), std::end(data)));
    std::sort(std::begin(data), std::end(data));
    assert(std::is_sorted(std::begin(data), std::end(data)));
    assert(not std::is_sorted(std::begin(data), std::end(data), std::greater<>{}));
}

Voir aussi

(C++11)
trouve la plus grande sous-plage triée
(fonction template)
(C++20)
vérifie si une plage est triée en ordre croissant
(objet fonction algorithme)