Namespaces
Variants

std:: bsearch

From cppreference.net
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)
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
Permutation operations
C library
bsearch
Numeric operations
Operations on uninitialized memory
Definiert im Header <cstdlib>
void * bsearch ( const void * key, const void * ptr, std:: size_t count,

std:: size_t size, /* c-compare-pred */ * comp ) ;
void * bsearch ( const void * key, const 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* )

Findet ein Element, das dem durch key referenzierten Element entspricht, in einem Array, auf das ptr zeigt. Das Array enthält count Elemente von jeweils size Bytes und muss bezüglich des durch key referenzierten Objekts partitioniert sein, d.h. alle Elemente, die kleiner vergleichen, müssen vor allen Elementen erscheinen, die gleich vergleichen, und diese müssen vor allen Elementen erscheinen, die größer vergleichen als das Schlüsselobjekt. Ein vollständig sortiertes Array erfüllt diese Anforderungen. Die Elemente werden mittels der durch comp referenzierten Funktion verglichen.

Das Verhalten ist undefiniert, wenn das Array nicht bereits in aufsteigender Reihenfolge bezüglich des Schlüssels partitioniert ist, gemäß demselben Kriterium, das comp verwendet.

Wenn das Array mehrere Elemente enthält, die comp als gleich dem gesuchten Element anzeigen würde, dann ist nicht spezifiziert, welches Element die Funktion als Ergebnis zurückgibt.

Inhaltsverzeichnis

Parameter

key - Zeiger auf das zu suchende Element
ptr - Zeiger auf das zu untersuchende 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. key wird als erstes Argument übergeben, ein Element aus dem Array als zweites.

Die Signatur der Vergleichsfunktion sollte der folgenden entsprechen:

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

Zeiger auf das gefundene Element oder Nullzeiger, falls das Element nicht gefunden wurde.

Hinweise

Trotz des Namens verlangen weder die C- noch die POSIX-Standards, dass diese Funktion mittels binärer Suche implementiert wird oder geben irgendwelche Komplexitä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

#include <array>
#include <cstdlib>
#include <iostream>
template<typename T>
int compare(const void *a, const void *b)
{
    const auto &arg1 = *(static_cast<const T*>(a));
    const auto &arg2 = *(static_cast<const T*>(b));
    const auto cmp = arg1 <=> arg2;
    return cmp < 0 ? -1
        :  cmp > 0 ? +1
        :  0;
}
int main()
{
    std::array arr{1, 2, 3, 4, 5, 6, 7, 8};
    for (const int key : {4, 8, 9})
    {
        const int* p = static_cast<int*>(
            std::bsearch(&key,
                arr.data(),
                arr.size(),
                sizeof(decltype(arr)::value_type),
                compare<int>));
        std::cout << "value " << key;
        if (p)
            std::cout << " found at position " << (p - arr.data()) << '\n';
        else
            std::cout << " not found\n";
    }
}

Ausgabe:

value 4 found at position 3
value 8 found at position 7
value 9 not found

Siehe auch

sortiert eine Reihe von Elementen mit unspezifiziertem Typ
(Funktion)
gibt den Bereich der Elemente zurück, die einem bestimmten Schlüssel entsprechen
(Funktions-Template)
C-Dokumentation für bsearch