`bsearch_s`

Artikel
08/03/2024

Führt eine binäre Suche eines sortierten Arrays aus. Diese Funktion ist eine Version von bsearch Sicherheitsverbesserungen, wie in den Sicherheitsfeatures im CRT beschrieben.

Syntax

void *bsearch_s(
   const void *key,
   const void *base,
   size_t number,
   size_t width,
   int ( __cdecl *compare ) ( void *, const void *key, const void *datum),
   void * context
);

Parameter

key
Zeigen Sie auf den Schlüssel, nach dem gesucht werden soll.

base
Zeigen Sie auf die Basis der Suchdaten.

number
Anzahl der Elemente.

width
Breite der Elemente.

compare
Rückruffunktion, die zwei Elemente vergleicht. Das erste Argument ist der context -Zeiger. Das zweite Argument ist ein Zeiger auf den key für die Suche. Das dritte Argument ist ein Zeiger auf das Arrayelement, das mit keyverglichen werden soll.

context
Ein Zeiger auf ein Objekt, auf das in der Vergleichsfunktion zugegriffen werden kann.

Rückgabewert

bsearch_s gibt einen Zeiger auf ein Vorkommen von key in dem Array zurück, auf das baseverweist. Wenn key nicht gefunden wird, gibt die Funktion zurück NULL. Wenn sich das Array nicht in aufsteigender Sortierreihenfolge befindet oder doppelte Datensätze mit identischen Schlüsseln enthält, ist das Ergebnis unvorhersehbar.

Wenn ungültige Parameter an die Funktion übergeben werden, wird der ungültige Parameterhandler aufgerufen, wie in der Parameterüberprüfung beschrieben. Wenn die weitere Ausführung zugelassen wird, wird errno auf EINVAL festgelegt, und die Funktion gibt NULLbeschrieben. Weitere Informationen finden Sie untererrno, _doserrno, _sys_errlistund _sys_nerr.

Fehlerbedingungen

`key`	`base`	`compare`	`number`	`width`	Wert vom Typ `errno`
`NULL`	any	Beliebig	Beliebig	Beliebig	`EINVAL`
Beliebig	`NULL`	any	!= 0	any	`EINVAL`
Beliebig	Beliebig	Beliebig	any	= 0	`EINVAL`
any	any	`NULL`	ein	any	`EINVAL`

Hinweise

Die bsearch_s -Funktion führt eine binäre Suche eines sortierten Arrays aus number Elementen aus, von denen jedes width Bytes groß ist. Der base -Wert ist ein Zeiger auf die Basis des zu durchsuchenden Arrays, und key ist der gesuchte Wert. Der compare -Parameter ist ein Zeiger auf eine vom Benutzer bereitgestellte Routine, die den angeforderten Schlüssel mit einem Arrayelement vergleicht und einen der folgenden Werte zur Angabe ihrer Beziehung zurückgibt:

Von der `compare` -Routine zurückgegebener Wert	Beschreibung
< 0	Der Schlüssel ist kleiner als das Arrayelement.
0	Schlüssel und Arrayelement sind gleich.
> 0	Der Schlüssel ist größer als das Arrayelement.

Der context -Zeiger kann nützlich sein, wenn die durchsuchte Datenstruktur Teil eines Objekts ist und die Vergleichsfunktion auf Member des Objekts zugreifen muss. Mithilfe der compare -Funktion kann möglicherweise der void-Zeiger in den passenden Objekttyp umgewandelt und auf Member des Objekts zugegriffen werden. Das Hinzufügen des context Parameters macht bsearch_s sicherer, da der Kontext verwendet werden kann, um Reentranzfehler zu vermeiden, die mit der Verwendung statischer Variablen verbunden sind, um Daten für die compare Funktion verfügbar zu machen.

Standardmäßig gilt der globale Zustand dieser Funktion für die Anwendung. Wie Sie dieses Verhalten ändern, erfahren Sie unter Globaler Status in der CRT.

Anforderungen

Routine	Erforderlicher Header
`bsearch_s`	<stdlib.h> und <search.h>

Weitere Informationen zur Kompatibilität finden Sie unter Kompatibilität.

Beispiel

Dieses Programm sortiert ein Zeichenfolgenarray mit qsort_sund verwendet dann bsearch_s, um das Wort "Katze" zu finden.

// crt_bsearch_s.cpp
// This program uses bsearch_s to search a string array,
// passing a locale as the context.
// compile with: /EHsc
#include <stdlib.h>
#include <stdio.h>
#include <search.h>
#include <process.h>
#include <locale.h>
#include <locale>
#include <windows.h>
using namespace std;

// The sort order is dependent on the code page.  Use 'chcp' at the
// command line to change the codepage.  When executing this application,
// the command prompt codepage must match the codepage used here:

#define CODEPAGE_850

#ifdef CODEPAGE_850
#define ENGLISH_LOCALE "English_US.850"
#endif

#ifdef CODEPAGE_1252
#define ENGLISH_LOCALE "English_US.1252"
#endif

// The context parameter lets you create a more generic compare.
// Without this parameter, you would have stored the locale in a
// static variable, thus making it vulnerable to thread conflicts
// (if this were a multithreaded program).

int compare( void *pvlocale, char **str1, char **str2)
{
    char *s1 = *str1;
    char *s2 = *str2;

    locale& loc = *( reinterpret_cast< locale * > ( pvlocale));

    return use_facet< collate<char> >(loc).compare(
       s1, s1+strlen(s1),
       s2, s2+strlen(s2) );
}

int main( void )
{
   char *arr[] = {"dog", "pig", "horse", "cat", "human", "rat", "cow", "goat"};

   char *key = "cat";
   char **result;
   int i;

   /* Sort using Quicksort algorithm: */
   qsort_s( arr,
            sizeof(arr)/sizeof(arr[0]),
            sizeof( char * ),
            (int (*)(void*, const void*, const void*))compare,
            &locale(ENGLISH_LOCALE) );

   for( i = 0; i < sizeof(arr)/sizeof(arr[0]); ++i )    /* Output sorted list */
      printf( "%s ", arr[i] );

   /* Find the word "cat" using a binary search algorithm: */
   result = (char **)bsearch_s( &key,
                                arr,
                                sizeof(arr)/sizeof(arr[0]),
                                sizeof( char * ),
                                (int (*)(void*, const void*, const void*))compare,
                                &locale(ENGLISH_LOCALE) );
   if( result )
      printf( "\n%s found at %Fp\n", *result, result );
   else
      printf( "\nCat not found!\n" );
}

cat cow dog goat horse human pig rat
cat found at 002F0F04

Siehe auch

Suchen und Sortieren
_lfind
_lsearch
qsort

Freigeben über