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
Definiert im Header <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) ( Nur zur Darstellung* )

Sortiert das gegebene Array, auf das durch ptr gezeigt wird, in aufsteigender Reihenfolge. Das Array enthält count Elemente von size Bytes. Die Funktion, auf die durch comp gezeigt wird, wird für den Objektvergleich verwendet.

Wenn comp zwei Elemente als äquivalent kennzeichnet, ist ihre Reihenfolge nicht spezifiziert.

Wenn der Typ der Elemente des Arrays kein PODType (bis C++11) TriviallyCopyable Typ (seit C++11) ist, ist das Verhalten undefiniert.

Inhaltsverzeichnis

Parameter

ptr - Zeiger auf das zu sortierende Array
count - Anzahl der Elemente im Array
size - Größe jedes Elements im Array in Bytes
comp - Vergleichsfunktion, die eine negative Ganzzahl zurückgibt, wenn das erste Argument kleiner als das zweite ist, eine positive Ganzzahl, wenn das erste Argument größer als das zweite ist, und null, wenn die Argumente äquivalent sind.

Die Signatur der Vergleichsfunktion sollte wie folgt lauten:

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

Die Funktion darf die übergebenen Objekte nicht modifizieren und muss konsistente Ergebnisse liefern, wenn sie für dieselben Objekte aufgerufen wird, unabhängig von deren Position im Array.

​

Rückgabewert

(keine)

Hinweise

Trotz des Namens verlangen die C++, C und POSIX Standards nicht, dass diese Funktion mittels Quicksort implementiert wird oder geben irgendwelche Komplexitäts- oder Stabilitätsgarantien.

Die beiden Überladungen, die von der C++-Standardbibliothek bereitgestellt werden, sind unterschiedlich, weil die Typen des Parameters comp unterschiedlich sind ( Sprachbindung ist Teil seines Typs).

Beispiel

Der folgende Code sortiert ein Array von Ganzzahlen mit qsort() :

Diesen Code ausführen 
#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';
}

Ausgabe: 

-2147483648 -743 -2 0 2 4 99 2147483647

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR Angewendet auf Verhalten wie veröffentlicht Korrektes Verhalten
LWG 405 C++98 die Elemente des Arrays konnten beliebigen Typ haben beschränkt auf PODType

Siehe auch

durchsucht ein Array nach einem Element unspezifizierten Typs
(Funktion)
sortiert einen Bereich in aufsteigender Reihenfolge
(Funktions-Template)
(C++11) (deprecated in C++26)
prüft, ob ein Typ trivial ist
(Klassen-Template)
C-Dokumentation für qsort