Namespaces
Variants

std:: qsort

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
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
qsort
Numeric operations
Operations on uninitialized memory
Défini dans l'en-tête <cstdlib>
void qsort ( void * ptr, std:: size_t count,

std:: size_t size, /* c-compare-pred */ * comp ) ;
void qsort ( void * ptr, std:: size_t count,

std:: size_t size, /* compare-pred */ * comp ) ;
(1)
extern "C" using /* c-compare-pred */ = int ( const void * , const void * ) ;
extern "C++" using /* compare-pred */ = int ( const void * , const void * ) ;
(2) ( exposition uniquement* )

Trie le tableau donné pointé par ptr en ordre croissant. Le tableau contient count éléments de size octets. La fonction pointée par comp est utilisée pour la comparaison des objets.

Si comp indique que deux éléments sont équivalents, leur ordre n'est pas spécifié.

Si le type des éléments du tableau n'est pas un PODType (jusqu'à C++11) TriviallyCopyable type (depuis C++11) , le comportement est indéfini.

Table des matières

Paramètres

ptr - pointeur vers le tableau à trier
count - nombre d'éléments dans le tableau
size - taille de chaque élément du tableau en octets
comp - fonction de comparaison qui retourne un entier négatif si le premier argument est inférieur au second, un entier positif si le premier argument est supérieur au second et zéro si les arguments sont équivalents.

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

int cmp ( const void * a, const void * b ) ;

La fonction ne doit pas modifier les objets qui lui sont passés et doit retourner des résultats cohérents lorsqu'elle est appelée pour les mêmes objets, indépendamment de leur position dans le tableau.

​

Valeur de retour

(aucun)

Notes

Malgré son nom, les normes C++, C et POSIX n'exigent pas que cette fonction soit implémentée en utilisant Quicksort ni ne fournissent aucune garantie concernant la complexité ou la stabilité.

Les deux surcharges fournies par la bibliothèque standard C++ sont distinctes car les types du paramètre comp sont distincts (la liaison de langage fait partie de son type).

Exemple

Le code suivant trie un tableau d'entiers en utilisant qsort() :

Exécuter ce code 
#include <array>
#include <climits>
#include <compare>
#include <cstdlib>
#include <iostream>
int main()
{
    std::array a{-2, 99, 0, -743, INT_MAX, 2, INT_MIN, 4};
    std::qsort
    (
        a.data(),
        a.size(),
        sizeof(decltype(a)::value_type),
        [](const void* x, const void* y)
        {
            const int arg1 = *static_cast<const int*>(x);
            const int arg2 = *static_cast<const int*>(y);
            const auto cmp = arg1 <=> arg2;
            if (cmp < 0)
                return -1;
            if (cmp > 0)
                return 1;
            return 0;
        }
    );
    for (int ai : a)
        std::cout << ai << ' ';
    std::cout << '\n';
}

Sortie : 

-2147483648 -743 -2 0 2 4 99 2147483647

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 publié Comportement corrigé
LWG 405 C++98 les éléments du tableau pouvaient avoir n'importe quel type limité à PODType

Voir aussi

recherche un élément de type non spécifié dans un tableau
(fonction)
trie une plage en ordre croissant
(modèle de fonction)
(C++11) (déprécié en C++26)
vérifie si un type est trivial
(modèle de classe)
Documentation C pour qsort