Namespaces
Variants

std::list<T,Allocator>:: sort

From cppreference.net

C++
Containers library
std::list
Member functions
Non-member functions
(until C++20) (until C++20) (until C++20) (until C++20) (until C++20)
Deduction guides (C++17)
void sort ( ) ;
(1) (constexpr depuis C++26)
template < class Compare >
void sort ( Compare comp ) ;
(2) (constexpr depuis C++26)

Trie les éléments et préserve l'ordre des éléments équivalents. Si une exception est levée, l'ordre des éléments dans * this n'est pas spécifié.

1) Les éléments sont comparés en utilisant operator < .
2) Les éléments sont comparés en utilisant comp .

Aucune référence ou itérateur n'est invalidé.

Table des matières

Paramètres

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 de 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 list < T,Allocator > :: const_iterator puisse être déréférencé puis implicitement converti vers les deux. ​

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

Complexité

Étant donné N comme size() :

1) Approximativement N·log(N) comparaisons en utilisant operator < .
2) Approximativement N·log(N) applications de la fonction de comparaison comp .

Notes

std::sort nécessite des itérateurs à accès aléatoire et ne peut donc pas être utilisé avec list . Cette fonction diffère également de std::sort en ce qu'elle ne nécessite pas que le type d'élément de la list soit permutable, préserve les valeurs de tous les itérateurs et effectue un tri stable.

Exemple

Exécuter ce code 
#include <functional>
#include <iostream>
#include <list>
std::ostream& operator<<(std::ostream& ostr, const std::list<int>& list)
{
    for (const int i : list)
        ostr << ' ' << i;
    return ostr;
}
int main()
{
    std::list<int> list{8, 7, 5, 9, 0, 1, 3, 2, 6, 4};
    std::cout << "initialement : " << list << '\n';
    list.sort();
    std::cout << "ascendant : " << list << '\n';
    list.sort(std::greater<int>());
    std::cout << "descendant :" << list << '\n';
}

Sortie : 

initialement :  8 7 5 9 0 1 3 2 6 4
ascendant :  0 1 2 3 4 5 6 7 8 9
descendant : 9 8 7 6 5 4 3 2 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 1207 C++98 il n'était pas clair si les itérateurs et/ou références seraient invalidés maintenir valides

Voir aussi

inverse l'ordre des éléments
(fonction membre publique)