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
Definido en el encabezado <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) ( solo para exposición* )

Ordena el arreglo dado apuntado por ptr en orden ascendente. El arreglo contiene count elementos de size bytes. La función apuntada por comp se utiliza para la comparación de objetos.

Si comp indica dos elementos como equivalentes, su orden no está especificado.

Si el tipo de los elementos del array no es un PODType (until C++11) TriviallyCopyable type (since C++11) , el comportamiento es indefinido.

Contenidos

Parámetros

ptr - puntero al array a ordenar
count - número de elementos en el array
size - tamaño de cada elemento del array en bytes
comp - función de comparación que retorna un valor entero negativo si el primer argumento es menor que el segundo, un valor entero positivo si el primer argumento es mayor que el segundo y cero si los argumentos son equivalentes.

La firma de la función de comparación debe ser equivalente a la siguiente:

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

La función no debe modificar los objetos pasados a ella y debe retornar resultados consistentes cuando se llama para los mismos objetos, independientemente de sus posiciones en el array.

​

Valor de retorno

(ninguno)

Notas

A pesar del nombre, los estándares de C++, C y POSIX no requieren que esta función se implemente utilizando Quicksort ni ofrecen garantías de complejidad o estabilidad.

Las dos sobrecargas proporcionadas por la biblioteca estándar de C++ son distintas porque los tipos del parámetro comp son distintos (el enlace de lenguaje es parte de su tipo).

Ejemplo

El siguiente código ordena un array de enteros usando qsort() :

Ejecutar este código 
#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';
}

Salida: 

-2147483648 -743 -2 0 2 4 99 2147483647

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

DR Aplicado a Comportamiento publicado Comportamiento correcto
LWG 405 C++98 los elementos del array podían tener cualquier tipo limitado a PODType

Véase también

busca un elemento de tipo no especificado en un arreglo
(función)
ordena un rango en orden ascendente
(plantilla de función)
(C++11) (deprecated in C++26)
verifica si un tipo es trivial
(plantilla de clase)
Documentación C para qsort