Namespaces
Variants

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

    From fr.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é.

    Contenu

    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)