bsearch_s

Effectue une recherche binaire dans un tableau trié. Cette fonction est une version des améliorations de bsearch sécurité décrites dans les fonctionnalités de sécurité du CRT.

Syntaxe

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
);

Paramètres

key
Pointeur vers la clé à rechercher.

base
Pointeur vers la base des données de recherche.

number
Nombre d'éléments.

width
Largeur des éléments.

compare
Fonction de rappel qui compare deux éléments. Le premier argument est le pointeur context . Le deuxième argument est un pointeur vers le key pour la recherche. Le troisième argument est un pointeur vers l’élément de tableau à comparer à key.

context
Pointeur vers un objet accessible dans la fonction de comparaison.

Valeur retournée

bsearch_s retourne un pointeur vers une occurrence de key du tableau pointé par base. Si key elle n’est pas trouvée, la fonction retourne NULL. Si le tableau n’est pas dans l’ordre croissant de tri ou contient des enregistrements en double avec des clés identiques, le résultat est imprévisible.

Si des paramètres non valides sont passés à la fonction, il appelle le gestionnaire de paramètres non valide, comme décrit dans la validation des paramètres. Si l’exécution est autorisée à se poursuivre, errno a la valeur EINVAL et la fonction retourne NULL. Pour plus d'informations, voir errno, _doserrno, _sys_errlist et _sys_nerr.

Conditions d’erreur

Notes

La fonction bsearch_s effectue une recherche binaire dans un tableau trié de number éléments, chacun d’une taille de width octets. La valeur de base est un pointeur vers la base du tableau dans lequel effectuer la recherche, et key est la valeur recherchée. Le paramètre compare est un pointeur vers une routine fournie par l’utilisateur qui compare la clé demandée à un élément de tableau et retourne l’une des valeurs suivantes précisant leur relation :

Le pointeur context peut être utile si la structure de données faisant l’objet de la recherche fait partie d’un objet, et la fonction de comparaison doit accéder aux membres de l’objet. La fonction compare peut effectuer une conversion de type (transtypage) du pointeur void vers le type d’objet approprié et accéder aux membres de cet objet. L’ajout du context paramètre rend bsearch_s plus sécurisé, car le contexte peut être utilisé pour éviter les bogues de réentrance associés à l’utilisation de variables statiques pour rendre les données disponibles pour la compare fonction.

Par défaut, l’état global de cette fonction est limité à l’application. Pour modifier ce comportement, consultez État global dans le CRT.

Spécifications

Pour plus d’informations sur la compatibilité, consultez Compatibility.

Exemple

Ce programme trie un tableau de chaînes avec qsort_s, puis utilise bsearch_s pour trouver le mot « chat ».

// 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

Voir aussi

Recherche et tri
_lfind
_lsearch
qsort