Namespaces
Variants

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

From cppreference.net

C++
Containers library
std::forward_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) (depuis C++11)
(constexpr depuis C++26)
template < class Compare >
void sort ( Compare comp ) ;
(2) (depuis C++11)
(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 à l'aide de 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 forward_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 std:: distance ( begin ( ) , end ( ) ) :

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 forward_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 forward_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 <forward_list>
std::ostream& operator<<(std::ostream& ostr, const std::forward_list<int>& list)
{
    for (const int i : list)
        ostr << ' ' << i;
    return ostr;
}
int main()
{
    std::forward_list<int> list{8, 7, 5, 9, 0, 1, 3, 2, 6, 4};
    std::cout << "initially: " << list << '\n';
    list.sort();
    std::cout << "ascending: " << list << '\n';
    list.sort(std::greater<int>());
    std::cout << "descending:" << list << '\n';
}

Sortie : 

initially:  8 7 5 9 0 1 3 2 6 4
ascending:  0 1 2 3 4 5 6 7 8 9
descending: 9 8 7 6 5 4 3 2 1 0

Voir aussi

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