`_lfind_s`

Artikel
10/12/2023

Führt eine lineare Suche für den angegebenen Schlüssel aus. Eine Version mit _lfind Sicherheitsverbesserungen, wie in den Sicherheitsfeatures in der CRT beschrieben.

Syntax

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

Parameter

key
Das Objekt, nach dem gesucht werden soll.

base
Zeiger auf die Basis der Suchdaten.

number
Die Anzahl der Arrayelemente.

size
Die Größe der Arrayelemente in Bytes.

compare
Zeiger auf die Vergleichsroutine. Der erste Parameter ist der context-Zeiger. Der zweite Parameter ist ein Zeiger auf den Schlüssel für die Suche. Der dritte Parameter ist ein Zeiger auf das Arrayelement, das mit dem Schlüssel verglichen werden soll.

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

Rückgabewert

Wenn der Schlüssel gefunden wird, gibt _lfind_s einen Zeiger auf das Arrayelement bei base zurück, das key entspricht. Wenn der Schlüssel nicht gefunden wird, _lfind_s wird zurückgegeben NULL.

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.

Fehlerbedingungen

`key`	`base`	`compare`	`number`	`size`	`errno`
`NULL`	Beliebig	Beliebig	Beliebig	Beliebig	`EINVAL`
Beliebig	`NULL`	Beliebig	!= 0	Beliebig	`EINVAL`
Beliebig	Beliebig	Beliebig	Beliebig	null	`EINVAL`
Beliebig	Beliebig	`NULL`	ein	Beliebig	`EINVAL`

Hinweise

Die _lfind_s-Funktion führt eine lineare Suche nach dem Wert key in einem Array aus number-Elementen durch, die jeweils aus size-Bytes bestehen. Im Gegensatz dazu bsearch_s_lfind_s muss das Array nicht sortiert werden. Das base-Argument ist ein Zeiger auf die Basis des zu suchenden Arrays. Das compare-Argument ist ein Zeiger auf eine benutzerdefinierte Routine, die zwei Arrayelemente vergleicht und einen Wert zurückgibt, der die Beziehung angibt. _lfind_s ruft die compare-Routine einmal oder mehrere Male während der Suche auf, wodurch bei jedem Aufruf der context-Zeiger übergeben wird und auf zwei Arrayelemente zeigt. Die compare-Routine muss die Elemente vergleichen und entweder ungleich null (d.h. die Elemente unterscheiden sich) oder 0 (d.h. die Elemente sind identisch) zurückgeben.

_lfind_s ähnelt _lfind mit Ausnahme der Hinzufügung des context-Zeigers auf den Argumenten der Vergleichsfunktion und der Parameterliste der Funktion. Der context-Zeiger kann nützlich sein, wenn die durchsuchte Datenstruktur Teil eines Objekts ist und die compare-Funktion 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 _lfind_s sicherer, da zusätzlicher Kontext verwendet werden kann, um Reentranzfehler zu vermeiden, die mit statischen 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. Informationen zum Ändern dieses Verhaltens finden Sie im Global state in the CRT.

Anforderungen

Routine	Erforderlicher Header
`_lfind_s`	<search.h>

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

Beispiel

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

weit found

Siehe auch

Suchen und Sortieren
bsearch_s
_lsearch_s
qsort_s
_lfind

Teilen über