bsearch_s

Effectue une recherche binaire d'un tableau trié.Il s'agit de version de bsearch avec des améliorations de sécurité comme décrit dans Fonctionnalités de sécurité du CRT.

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

Paramètres

• key
  Objet à rechercher.

• base
  Pointeur vers la base de données de correspondance.

• num
  Nombre d'éléments.

• width
  largeur des éléments.

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

• context
  Un pointeur vers un objet accessible dans la fonction de comparaison.

Valeur de retour

bsearch_s retourne un pointeur vers une occurrence d'key du tableau désignée par base.Si key est introuvable, la fonction retourne NULL.Si le tableau n'est pas dans l'ordre de tri croissant ou ne contient pas les enregistrements en double avec les clés identiques, le résultat est imprévisible.

Si des paramètres incorrects sont passés à la fonction, le gestionnaire de paramètre non valide est appelé comme décrit dans Validation des paramètres.Si est autorisé à l'exécution de se poursuivre, errnoest défini à EINVAL et la fonction retourne NULL.Pour plus d'informations, consultez errno, _doserrno, _sys_errlist, et _sys_nerr.

conditions d'erreur

Notes

La fonction d' bsearch_s effectue une recherche binaire d'un tableau trié d'éléments d' num , chacun d'octets d' width en taille.La valeur d' base est un pointeur vers la base du tableau à rechercher, et key est la valeur recherchée.Le paramètre d' compare est un pointeur vers une routine fournie par l'utilisateur qui compare la clé demandée à un élément de tableau et retourne une des valeurs suivantes spécifiant les relations :

Le pointeur d' context peut être utile si la structure de données trouvée fait partie d'un objet, et la fonction de comparaison doit accéder aux membres de l'objet.La fonction d' compare peut effectuer un cast du pointeur void dans le type d'objet approprié et accéder aux membres de cet objet.L'ajout du paramètre d' context rend bsearch_s plus sécurisées étant donné que le contexte supplémentaire peut être utilisé pour éviter les bogues de réentrance associés à utiliser des variables statiques de rendre des données disponibles à la fonction d' compare .

Configuration requise

Pour des informations de compatibilité supplémentaires, consultez Compatibilité dans l'introduction.

Exemple

Ce programme trie une table de chaînes avec qsort_s, puis utilise des bsearch_s pour rechercher 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" );
}

Équivalent .NET Framework

BinarySearch

Voir aussi

Référence

Rechercher et trier

_lfind

_lsearch

qsort