_lfind_s

Article
03/04/2013

Exécute une recherche linéaire pour la clé spécifiée.Une version de _lfind avec des améliorations de sécurité comme décrit dans Fonctionnalités de sécurité du CRT.

void *_lfind_s(
   const void *key,
   const void *base,
   unsigned int *num,
   size_t size,
   int (__cdecl *compare)(void *, const void *, const void *),
   void * context
);

Paramètres

key
Objet à rechercher.
base
Pointeur vers la base de données de correspondance.
num
Nombre d'éléments de tableau.
size
taille des éléments de tableau en octets.
compare
Pointeur vers la routine de comparaison.le premier paramètre est le pointeur d' context .le deuxième paramètre est un pointeur à indexer pour la recherche.Le troisième est un pointeur vers l'élément de tableau à comparer à la clé.
context
Un pointeur vers un objet qui peut être accédé depuis la fonction de comparaison.

Valeur de retour

Si la clé est trouvée, _lfind_s retourne un pointeur vers l'élément du tableau à l'adresse base qui correspond à key.Si la clé est introuvable, _lfind_s retourne NULL.

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, errno est défini à EINVAL et la fonction retourne NULL.

conditions d'erreur

clé	base	compare	num	taille	errno
NULL	quels	quels	quels	quels	EINVAL
quels	NULL	quels	!= 0	quels	EINVAL
quels	quels	quels	quels	zéro	EINVAL
quels	quels	NULL	un	quels	EINVAL

Notes

La fonction d' _lfind_s exécute une recherche linéaire pour la valeur key dans un tableau d'éléments d' num , chacun d'octets d' width .Contrairement à bsearch_s, _lfind_s ne requiert pas le tableau à trier.L'argument d' base est un pointeur vers la base du tableau à rechercher.L'argument d' compare est un pointeur vers une routine fournie par l'utilisateur qui compare deux éléments de tableau puis retourne une valeur spécifiant leur relation._lfind_s appelle la routine d' compare une ou plusieurs fois pendant la recherche, en passant le pointeur d' context et les pointeurs à deux éléments de tableau à chaque appel.La routine d' compare doit comparer les éléments puis à une valeur différente de zéro de retour (c'est-à-dire que les éléments sont différents) ou le 0 (en c'est-à-dire les éléments et sont identiques).

_lfind_s est semblable à _lfind à l'exception de l'ajout du pointeur d' context aux arguments de la fonction de comparaison et de la liste de paramètres de la fonction.Le pointeur d' context peut être utile si la structure de données trouvée fait partie d'un objet et la fonction d' compare 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 _lfind_s plus sécurisées car 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

routine	en-tête requis
_lfind_s	<search.h>

Pour plus d'informations de compatibilité, consultez Compatibilité dans l'introduction.

Exemple

// crt_lfind_s.cpp
// This program uses _lfind_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
// Codepage 850 is the OEM codepage used by the command line,
// so \x00e1 is the German Sharp S

char *array1[] = { "wei\x00e1", "weis", "annehmen", "weizen", "Zeit",
                   "weit" };

#define GERMAN_LOCALE "German_Germany.850"

#endif

#ifdef CODEPAGE_1252
   // If using codepage 1252 (ISO 8859-1, Latin-1), use \x00df
   // for the German Sharp S
char *array1[] = { "wei\x00df", "weis", "annehmen", "weizen", "Zeit",
                   "weit" };

#define GERMAN_LOCALE "German_Germany.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, const void *str1, const void *str2)
{
    char *s1 = *(char**)str1;
    char *s2 = *(char**)str2;

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

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

void find_it( char *key, char *array[], unsigned int num, locale &loc )
{
   char **result = (char **)_lfind_s( &key, array, 
                      &num, sizeof(char *), compare, &loc );
   if( result )
      printf( "%s found\n", *result );
   else
      printf( "%s not found\n", key );
}

int main( )
{
   find_it( "weit", array1, sizeof(array1)/sizeof(char*), locale(GERMAN_LOCALE) );
}