manpages-de - en to de translation catalogue (51 entries)

note: type: TH
en: 2019-03-06
de: 6. März 2019

note: type: TH
en: Linux Programmer's Manual
de: Linux-Programmierhandbuch

note: type: SH
en: NAME
de: BEZEICHNUNG

note: type: Plain text
en: hcreate, hdestroy, hsearch, hcreate_r, hdestroy_r, hsearch_r - hash table management
de: hcreate, hdestroy, hsearch, hcreate_r, hdestroy_r, hsearch_r - Verwaltung von Hash-Tabellen

note: type: SH
en: SYNOPSIS
de: ÜBERSICHT

note: type: Plain text
en: B<#define _GNU_SOURCE>         /* See feature_test_macros(7) */
    B<#include E<lt>search.hE<gt>>
de: B<#define _GNU_SOURCE>         /* siehe feature_test_macros(7) */
    B<#include E<lt>search.hE<gt>>

note: type: SH
en: DESCRIPTION
de: BESCHREIBUNG

note: type: Plain text
en: The three functions B<hcreate>(), B<hsearch>(), and B<hdestroy>()  allow the caller to create and manage a hash search table containing entries consisting of a key (a string) and associated data.  Using these functions, only one hash table can be used at a time.
de: Die drei Funktionen B<hcreate>(), B<hsearch>() und B<hdestroy>() ermöglichen dem Aufrufer die Erstellung und Verwaltung einer Hash-Suchtabelle. Deren Einträge sind Paare aus einem Schlüssel (eine Zeichenkette) und zugeordneten Daten. Mit diesen Funktionen kann immer nur eine Hash-Tabelle genutzt werden.

note: type: Plain text
en: The three functions B<hcreate_r>(), B<hsearch_r>(), B<hdestroy_r>()  are reentrant versions that allow a program to use more than one hash search table at the same time.  The last argument, I<htab>, points to a structure that describes the table on which the function is to operate.  The programmer should treat this structure as opaque (i.e., do not attempt to directly access or modify the fields in this structure).
de: Die drei Funktionen B<hcreate_r>(), B<hsearch_r>(), B<hdestroy_r>() sind ablaufinvariante Funktionen, die überdies Programmen ermöglichen, mit mehreren Hash-Tabellen gleichzeitig zu arbeiten. Das letzte Argument, I<htab>, zeigt auf eine Struktur mit der Beschreibung der Hash-Tabelle, die die Funktion verwenden soll. Der Programmierer sollte diese Struktur als »undurchsichtig« behandeln (d.h. er sollte nicht versuchen, direkt auf Felder der Struktur zuzugreifen oder zu verändern).

note: e.g., in glibc it is raised to the next higher prime number type: Plain text
en: First a hash table must be created using B<hcreate>().  The argument I<nel> specifies the maximum number of entries in the table.  (This maximum cannot be changed later, so choose it wisely.)  The implementation may adjust this value upward to improve the performance of the resulting hash table.
de: Zuerst muss mittels B<hcreate>() eine Hash-Tabelle erzeugt werden. Das Argument I<nel> gibt die Maximalzahl der Einträge in der Tabelle an. (Dieses Maximum kann in der Folge nicht geändert werden, wählen Sie es also mit Bedacht.) Es ist möglich, dass die Implementierung diesen Wert nach oben anpasst, um die Leistungsfähigkeit der resultierenden Hash-Tabelle zu verbessern.

note: type: Plain text
en: The B<hcreate_r>()  function performs the same task as B<hcreate>(), but for the table described by the structure I<*htab>.  The structure pointed to by I<htab> must be zeroed before the first call to B<hcreate_r>().
de: Die Funktion B<hcreate_r>() erledigt die gleiche Aufgabe wie B<hcreate>(), tut das aber für die Tabelle, die durch die Struktur I<*htab> beschrieben wird. Vor dem ersten Aufruf von B<hcreate_r>() muss die Struktur I<htab> mit Nullen initialisiert werden.

note: type: Plain text
en: The function B<hdestroy>()  frees the memory occupied by the hash table that was created by B<hcreate>().  After calling B<hdestroy>(), a new hash table can be created using B<hcreate>().  The B<hdestroy_r>()  function performs the analogous task for a hash table described by I<*htab>, which was previously created using B<hcreate_r>().
de: Die Funktion B<hdestroy>() gibt den Speicher frei, den die von B<hcreate>() erzeugte Hash-Tabelle beansprucht. Nach dem Aufruf von B<hdestroy>() kann mittels B<hcreate>() eine neue Hash-Tabelle erzeugt werden. Die Funktion B<hdestroy_r>() erledigt die analoge Aufgabe für die durch I<*htab> beschriebene Hash-Tabelle, die zuvor mittels B<hcreate_r>() erzeugt wurde.

note: type: Plain text
en: The B<hsearch>()  function searches the hash table for an item with the same key as I<item> (where "the same" is determined using B<strcmp>(3)), and if successful returns a pointer to it.
de: Die Funktion B<hsearch>() durchsucht die Hash-Tabelle nach einem Eintrag mit dem gleichen Schlüssel wie I<item> (wobei »der gleiche« mittels B<strcmp>(3) bestimmt wird) und gibt bei Erfolg einen Zeiger auf diesen Eintrag zurück.

note: type: Plain text
en: The argument I<item> is of type I<ENTRY>, which is defined in I<E<lt>search.hE<gt>> as follows:
de: Das Argument I<item> ist vom Typ I<ENTRY>, der in I<E<lt>search.hE<gt>> wie folgt definiert wird:

note: type: Plain text
en: The field I<key> points to a null-terminated string which is the search key.  The field I<data> points to data that is associated with that key.
de: Das Feld I<key> zeigt auf eine null-terminierte Zeichenkette, die als Suchschlüssel dient. Das Feld I<data> zeigt auf dem Schlüssel zugeordnete Daten.

note: type: Plain text
en: The argument I<action> determines what B<hsearch>()  does after an unsuccessful search.  This argument must either have the value B<ENTER>, meaning insert a copy of I<item> (and return a pointer to the new hash table entry as the function result), or the value B<FIND>, meaning that NULL should be returned.  (If I<action> is B<FIND>, then I<data> is ignored.)
de: Das Argument I<action> bestimmt, was B<hsearch>() nach einer erfolglosen Suche unternimmt. Dieses Argument muss einen von zwei Werten annehmen: für den Wert B<ENTER> soll eine Kopie von I<item> in die Tabelle eingefügt werden (und ein Zeiger auf den neuen Eintrag in der Hash-Tabelle als Ergebnis der Funktion zurückgegeben werden); B<FIND> bedeutet, dass NULL zurückgegeben werden sollte. (Falls I<action> gleich B<FIND> ist, wird I<data> ignoriert.)

note: type: Plain text
en: The B<hsearch_r>()  function is like B<hsearch>()  but operates on the hash table described by I<*htab>.  The B<hsearch_r>()  function differs from B<hsearch>()  in that a pointer to the found item is returned in I<*retval>, rather than as the function result.
de: Die Funktion B<hsearch_r>() arbeitet wie B<hsearch>(), aber mit der durch I<*htab> beschriebenen Hash-Tabelle. Der Unterschied zwischen B<hsearch_r>() und B<hsearch>() ist, das der Zeiger auf den gefundenen Eintrag in I<*retval> zurückgegeben wird und nicht als Funktionsergebnis.

note: type: SH
en: RETURN VALUE
de: RÜCKGABEWERT

note: type: Plain text
en: B<hcreate>()  and B<hcreate_r>()  return nonzero on success.  They return 0 on error, with I<errno> set to indicate the cause of the error.
de: B<hcreate>() und B<hcreate_r>() geben bei Erfolg einen Wert ungleich null zurück; im Fehlerfall 0, wobei I<errno> auf die Ursache des Fehlers gesetzt wird.

note: type: Plain text
en: On success, B<hsearch>()  returns a pointer to an entry in the hash table.  B<hsearch>()  returns NULL on error, that is, if I<action> is B<ENTER> and the hash table is full, or I<action> is B<FIND> and I<item> cannot be found in the hash table.  B<hsearch_r>()  returns nonzero on success, and 0 on error.  In the event of an error, these two functions set I<errno> to indicate the cause of the error.
de: Bei Erfolg gibt B<hsearch>() einen Zeiger auf einen Eintrag in der Hash-Tabelle zurück. Bei einem Fehler gibt B<hsearch>() NULL zurück. Fehler treten auf, wenn die gewünschte I<action> B<ENTER> und die Hash-Tabelle voll ist oder wenn die I<action> B<FIND> ist und I<item> nicht in der Hash-Tabelle gefunden werden kann. Im Fehlerfall setzen diese zwei Funktionen I<errno>, um die Ursache des Fehlers anzuzeigen.

note: type: SH
en: ERRORS
de: FEHLER

note: type: Plain text
en: B<hcreate_r>()  and B<hdestroy_r>()  can fail for the following reasons:
de: B<hcreate_r>() und B<hdestroy_r>() können aus den folgenden Gründen fehlschlagen:

note: type: Plain text
en: I<htab> is NULL.
de: I<htab> ist NULL.

note: type: Plain text
en: B<hsearch>()  and B<hsearch_r>()  can fail for the following reasons:
de: B<hsearch>() und B<hsearch_r>()  können aus den folgenden Gründen fehlschlagen:

note: type: Plain text
en: I<action> was B<ENTER>, I<key> was not found in the table, and there was no room in the table to add a new entry.
de: Die I<action> war B<ENTER>, I<key> wurde nicht in der Tabelle gefunden und es war nicht ausreichend Platz für einen neuen Eintrag vorhanden.

note: type: Plain text
en: I<action> was B<FIND>, and I<key> was not found in the table.
de: Die I<action> war B<FIND> und I<key> wurde nicht in der Tabelle gefunden.

note: PROX.1-2001, POSIX.1-2008 type: Plain text
en: POSIX.1 specifies only the B<ENOMEM> error.
de: POSIX.1 beschreibt nur den Fehler B<ENOMEM>.

note: type: SH
en: ATTRIBUTES
de: ATTRIBUTE

note: type: Plain text
en: For an explanation of the terms used in this section, see B<attributes>(7).
de: Siehe B<attributes>(7) für eine Erläuterung der in diesem Abschnitt verwandten Ausdrücke.

note: type: tbl table
en: Interface
de: Schnittstelle

note: type: tbl table
en: Attribute
de: Attribut

note: type: tbl table
en: Value
de: Wert

note: type: tbl table
en: Thread safety
de: Multithread-Fähigkeit

note: type: SH
en: CONFORMING TO
de: KONFORM ZU

note: type: Plain text
en: The functions B<hcreate>(), B<hsearch>(), and B<hdestroy>()  are from SVr4, and are described in POSIX.1-2001 and POSIX.1-2008.
de: Die Funktionen B<hcreate>(), B<hsearch>() und B<hdestroy>() stammen aus SVr4 und werden in POSIX.1-2001 und POSIX.1-2008 beschrieben.

note: type: Plain text
en: The functions B<hcreate_r>(), B<hsearch_r>(), and B<hdestroy_r>()  are GNU extensions.
de: Die Funktionen B<hcreate_r>(), B<hsearch_r>() und B<hdestroy_r>() sind GNU-Erweiterungen.

note: type: SH
en: NOTES
de: ANMERKUNGEN

note: type: Plain text
en: Hash table implementations are usually more efficient when the table contains enough free space to minimize collisions.  Typically, this means that I<nel> should be at least 25% larger than the maximum number of elements that the caller expects to store in the table.
de: Implementierungen von Hash-Tabellen sind in der Regel effizienter, wenn die Tabelle ausreichend freien Raum bereitstellt, um Kollisionen zu reduzieren. Typischerweise bedeutet das, dass I<nel> mindestens 25% größer als sein sollte als die maximale Anzahl von Elementen, die der Aufrufende in der Tabelle zu speichern erwartet.

note: type: Plain text
en: The B<hdestroy>()  and B<hdestroy_r>()  functions do not free the buffers pointed to by the I<key> and I<data> elements of the hash table entries.  (It can't do this because it doesn't know whether these buffers were allocated dynamically.)  If these buffers need to be freed (perhaps because the program is repeatedly creating and destroying hash tables, rather than creating a single table whose lifetime matches that of the program), then the program must maintain bookkeeping data structures that allow it to free them.
de: Die Funktionen B<hdestroy>() und B<hdestroy_r>() geben die Puffer nicht frei, auf die die Elemente I<key> und I<data> der Einträge in der Hash-Tabelle weisen. (Das können sie nicht tun, weil sie nicht wissen, ob diese Puffer dynamisch zugewiesen wurden.) Falls diese Puffer freigegeben werden müssen (vielleicht, weil das Programm wiederholt Hash-Tabellen erzeugt und wieder freigibt, anstatt eine einzelne Tabelle über die Programmlaufzeit hinweg zu pflegen), dann muss das Programm Datenstrukturen zur Speicherverwaltung pflegen, um die Elemente der Tabelleneinträge freigeben zu können.

note: type: SH
en: BUGS
de: FEHLER

note: type: Plain text
en: SVr4 and POSIX.1-2001 specify that I<action> is significant only for unsuccessful searches, so that an B<ENTER> should not do anything for a successful search.  In libc and glibc (before version 2.3), the implementation violates the specification, updating the I<data> for the given I<key> in this case.
de: SVr4 und POSIX.1-2001 geben an, dass I<action> nur für erfolglose Suchen von Bedeutung ist, so dass ein B<ENTER> nichts für eine erfolgreiche Suche tun sollte. In Libc und Glibc (vor Version 2.3) verstößt die Implementierung gegen die Spezifikation und aktualisiert in diesem Fall I<data> für den gegebenen I<key>.

note: type: Plain text
en: Individual hash table entries can be added, but not deleted.
de: Einzelne Einträge können der Hash-Tabelle hinzugefügt, jedoch nicht gelöscht werden.

note: type: SH
en: EXAMPLE
de: BEISPIEL

note: type: Plain text
en: The following program inserts 24 items into a hash table, then prints some of them.
de: Das folgende Programm fügt 24 Einträge in eine Hashtabelle ein und zeigt dann einige davon an.

note: type: Plain text
en:     for (i = 0; i E<lt> 24; i++) {
            e.key = data[i];
            /* data is just an integer, instead of a
               pointer to something */
            e.data = (void *) i;
            ep = hsearch(e, ENTER);
            /* there should be no failures */
            if (ep == NULL) {
                fprintf(stderr, "entry failed\en");
                exit(EXIT_FAILURE);
            }
        }
de:     for (i = 0; i E<lt> 24; i++) {
            e.key = data[i];
            /* Datum ist nur eine Ganzzahl, anstatt eines 
               Zeigers auf irgendwas */
            e.data = (void *) i;
            ep = hsearch(e, ENTER);
            /* Es sollten keine Fehler eintreten */
            if (ep == NULL) {
                fprintf(stderr, "Eintrag fehlgeschlagen\en");
                exit(EXIT_FAILURE);
            }
        }

note: type: Plain text
en:     for (i = 22; i E<lt> 26; i++) {
            /* print two entries from the table, and
               show that two are not in the table */
            e.key = data[i];
            ep = hsearch(e, FIND);
            printf("%9.9s -E<gt> %9.9s:%d\en", e.key,
                   ep ? ep-E<gt>key : "NULL", ep ? (int)(ep-E<gt>data) : 0);
        }
        hdestroy();
        exit(EXIT_SUCCESS);
    }
de:     for (i = 22; i E<lt> 26; i++) {
            /* Zwei Einträge aus der Tabelle ausgeben und zeigen,
               dass zwei nicht in der Tabelle sind */
            e.key = data[i];
            ep = hsearch(e, FIND);
            printf("%9.9s -E<gt> %9.9s:%d\en", e.key,
                   ep ? ep-E<gt>key : "NULL", ep ? (int)(ep-E<gt>data) : 0);
        }
        hdestroy();
        exit(EXIT_SUCCESS);
    }

note: type: SH
en: SEE ALSO
de: SIEHE AUCH

note: type: SH
en: COLOPHON
de: KOLOPHON

note: type: Plain text
en: This page is part of release 5.03 of the Linux I<man-pages> project.  A description of the project, information about reporting bugs, and the latest version of this page, can be found at \%https://www.kernel.org/doc/man-pages/.
de: Diese Seite ist Teil der Veröffentlichung 5.03 des Projekts Linux-I<man-pages>. Eine Beschreibung des Projekts, Informationen, wie Fehler gemeldet werden können sowie die aktuelle Version dieser Seite finden sich unter \%https://www.kernel.org/doc/man-pages/.

note: type: Plain text
en: This page is part of release 5.02 of the Linux I<man-pages> project.  A description of the project, information about reporting bugs, and the latest version of this page, can be found at \%https://www.kernel.org/doc/man-pages/.
de: Diese Seite ist Teil der Veröffentlichung 5.02 des Projekts Linux-I<man-pages>. Eine Beschreibung des Projekts, Informationen, wie Fehler gemeldet werden können sowie die aktuelle Version dieser Seite finden sich unter \%https://www.kernel.org/doc/man-pages/.

note: type: Plain text
en: This page is part of release 5.01 of the Linux I<man-pages> project.  A description of the project, information about reporting bugs, and the latest version of this page, can be found at \%https://www.kernel.org/doc/man-pages/.
de: Diese Seite ist Teil der Veröffentlichung 5.01 des Projekts Linux-I<man-pages>. Eine Beschreibung des Projekts, Informationen, wie Fehler gemeldet werden können sowie die aktuelle Version dieser Seite finden sich unter \%https://www.kernel.org/doc/man-pages/.
