perkamon - en to fr translation catalogue (106 entries)

note: type: TH
en: 2003-11-01
fr: 1er novembre 2003

note: type: TH
en: Linux Programmer's Manual
fr: Manuel du programmeur Linux

note: type: SH
en: NAME
fr: NOM

note: type: Plain text
en: bsearch - binary search of a sorted array
fr: bsearch - Recherche dichotomique dans un tableau trié

note: type: Plain text
en: The B<bsearch>()  function searches an array of I<nmemb> objects, the initial member of which is pointed to by I<base>, for a member that matches the object pointed to by I<key>.  The size of each member of the array is specified by I<size>.
fr: La fonction B<bsearch>() recherche l'objet correspondant à I<key>, dans un tableau de I<nmemb> objets, commençant à l'adresse I<base>. La taille de chaque élément du tableau est indiquée dans I<size>.

note: type: Plain text
en: The contents of the array should be in ascending sorted order according to the comparison function referenced by I<compar>.  The I<compar> routine is expected to have two arguments which point to the I<key> object and to an array member, in that order, and should return an integer less than, equal to, or greater than zero if the I<key> object is found, respectively, to be less than, to match, or be greater than the array member.
fr: Le contenu du tableau doit être trié en ordre croissant par rapport à la fonction de comparaison référencée par I<compar>. La routine I<compar> doit être capable de recevoir deux arguments, le premier pointant sur l'objet I<key>, et le second sur un élément du tableau (l'ordre des arguments est toujours respecté par B<bsearch>). Cette routine doit retourner une valeur entière respectivement inférieure, égale ou supérieure à zéro si l'objet I<key> est inférieur, égal, ou supérieur à l'élément du tableau.

note: type: SH
en: RETURN VALUE
fr: VALEUR RENVOYÉE

note: type: Plain text
en: The B<bsearch>()  function returns a pointer to a matching member of the array, or NULL if no match is found.  If there are multiple elements that match the key, the element returned is unspecified.
fr: La fonction B<bsearch>() renvoie un pointeur sur l'élément du tableau correspondant à celui recherché, ou NULL si aucun élément ne correspond. Si plusieurs éléments du tableau correspondent à la clé, celui qui est renvoyé n'est pas spécifié.

note: type: SH
en: CONFORMING TO
fr: CONFORMITÉ

note: type: Plain text
en: SVr4, 4.3BSD, POSIX.1-2001, C89, C99.
fr: SVr4, BSD\ 4.3, POSIX.1-2001, C89, C99

note: type: SH
en: EXAMPLE
fr: EXEMPLE

note: type: Plain text
en: The example below first sorts an array of structures using B<qsort>(3), then retrieves desired elements using B<bsearch>().
fr: L'exemple suivant trie d'abord un tableau de structures en utilisant B<qsort>(3), puis retrouve les éléments désirés en utilisant B<bsearch>().

note: type: SH
en: SEE ALSO
fr: VOIR AUSSI

note: type: Plain text
en: This page is part of release 3.65 of the Linux I<man-pages> project.  A description of the project, and information about reporting bugs, can be found at \%http://www.kernel.org/doc/man-pages/.
fr: Cette page fait partie de la publication 3.65 du projet I<man-pages> Linux. Une description du projet et des instructions pour signaler des anomalies peuvent être trouvées à l'adresse \%http://www.kernel.org/doc/man-pages/.

note: type: TH
en: 2014-01-05
fr: 5 janvier 2014

note: type: Plain text
en: hcreate, hdestroy, hsearch, hcreate_r, hdestroy_r, hsearch_r - hash table management
fr: hcreate, hdestroy, hsearch, hcreate_r, hdestroy_r, hsearch_r - Gestion de table de hachage

note: type: Plain text
en: B<#define _GNU_SOURCE>         /* See feature_test_macros(7) */
fr: B<#define _GNU_SOURCE>         /* Consultez feature_test_macros(7) */

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.
fr: Les trois fonctions B<hcreate>(), B<hsearch>() et B<hdestroy>() permettent à l'utilisateur de créer et de gérer une table de hachage qui associe une clé (une chaîne de caractères) avec des données quelconques. Une seule table de hachage peut être utilisée à la fois avec ces fonctions.

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).
fr: Les fonctions B<hcreate_r>(), B<hsearch_r>() et B<hdestroy_r>() sont des versions réentrantes qui permettent d'utiliser plusieurs tables en même temps. Le dernier argument I<htab> pointe vers une structure qui identifie la table à utiliser. Le programmeur doit traiter la structure comme opaque (par exemple, il est impossible d'accéder ou de modifier la table de hachage depuis cette structure).

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.
fr: La table doit d'abord être créée avec B<hcreate>(). L'argument I<nel> est le nombre maximal d'éléments de la table (le maximum ne peut pas être changé pas la suite). L'implémentation peut décider d'augmenter cette valeur, afin d'améliorer les performances de la table de hachage.

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>().
fr: B<hcreate_r>() effectue la même tâche que B<hcreate>() mais pour les tables décrites par la structure I<*htab>. La structure pointée par I<htab> doit être initialisée avec des zéros avant le premier appel à B<hcreate_r>().

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>().
fr: La fonction B<hdestroy>() libère la mémoire occupée par la table de hachage créée par B<hcreate>(). Après un appel à B<hdestroy>(), une nouvelle table de hachage peut être créée avec B<hcreate>(). La fonction B<hdestroy_r>() effectue la même tâche pour une table de hachage décrite par I<*htab>, qui a été préalablement créée par B<hcreate_r>().

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.
fr: B<hsearch>() cherche dans la table de hachage un élément dont la clé est la même que I<item> (au sens de B<strcmp>(3)), et retourne un pointeur sur cet élément si la recherche réussit.

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:
fr: L'argument I<item> est du type I<ENTRY>, qui est défini dans I<E<lt>search.hE<gt>> ainsi\ :

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.
fr: Le champ I<key> pointe vers une chaîne terminée par un caractère nul qui est la clé cherchée. Le champ I<data> pointe vers les données associées à la clé.

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.)
fr: Le paramètre I<action> détermine ce que doit faire B<hsearch>() après une recherche infructueuse. Si I<action> est égal à B<ENTER>, alors une copie de I<item> est insérée et un pointeur sur ce nouvel élément est renvoyé. Si I<action> est égal à B<FIND>, NULL est renvoyé et I<data> est ignoré.

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.
fr: B<hsearch_r>() est similaire à B<hsearch>(), mais elle opère sur la table de hachage décrite par I<*htab>, et le pointeur de l'objet trouvé est renvoyé dans I<*retval> et non dans la valeur de retour de la fonction.

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.
fr: B<hcreate>() et B<hcreate_r>() renvoient une valeur non nulle en cas de  succès. En cas d'erreur, 0 est renvoyé et I<errno> contient le code d'erreur.

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.
fr: En cas de succès, B<hsearch> renvoie un pointeur vers une entrée de la table de hachage. Elle renvoie NULL en cas d'erreur ou si I<action> est égal à B<ENTER>, et la table de hachage pleine, ou  si I<action> est égal à B<FIND>, et I<item> ne peut pas être trouvé. B<hsearch_r>() renvoie une valeur non nulle en cas de succès et zéro en cas d'erreur.En cas d'erreur de ces fonctions, I<errno> contient le code d'erreur.

note: type: SH
en: ERRORS
fr: ERREURS

note: type: Plain text
en: B<hcreate_r>()  and B<hdestroy_r>()  can fail for the following reasons:
fr: B<hcreate_r>() et B<hdestroy_r>() peuvent échouer pour les raisons suivantes\ :

note: type: Plain text
en: I<htab> is NULL.
fr: I<htab> est NULL.

note: type: Plain text
en: B<hsearch>()  and B<hsearch_r>()  can fail for the following reasons:
fr: B<hsearch> et B<hsearch_r> peuvent échouer pour les raisons suivantes\ :

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.
fr: I<action> est B<ENTER>, I<key> n'a pas été trouvé dans la table, et il n'y a plus de place dans la table pour ajouter un nouvel élément.

note: type: Plain text
en: I<action> was B<FIND>, and I<key> was not found in the table.
fr: I<action> vaut B<FIND> et I<key> n'a pas été trouvé dans la table.

note: type: Plain text
en: POSIX.1-2001 specifies only the B<ENOMEM> error.
fr: POSIX.1-2001 spécifie seulement l'erreur B<ENOMEM>.

note: type: SH
en: ATTRIBUTES
fr: ATTRIBUTS

note: type: SS
en: Multithreading (see pthreads(7))
fr: Multithreading (voir pthreads(7))

note: type: Plain text
en: The B<hcreate>(), B<hsearch>(), and B<hdestroy>()  functions use a global space for storing the table, so they are not thread-safe.
fr: Les fonctions B<hcreate>(), B<hsearch>() et B<hdestroy>() ne sont pas sûres dans un contexte multithread car elles utilisent un espace global pour stocker la table.

note: type: Plain text
en: The B<hcreate_r>(), B<hsearch_r>(), and B<hdestroy_r>()  functions are thread-safe.
fr: Les fonctions B<hcreate_r>(), B<hsearch_r>() et B<hdestroy_r>() sont sûres dans un contexte multithread.

note: type: Plain text
en: The functions B<hcreate>(), B<hsearch>(), and B<hdestroy>()  are from SVr4, and are described in POSIX.1-2001.  The functions B<hcreate_r>(), B<hsearch_r>(), and B<hdestroy_r>()  are GNU extensions.
fr: Les fonctions B<hcreate>(), B<hsearch>() et B<hdestroy>() viennent de SVr4, et sont décrites dans POSIX.1-2001. Les fonctions B<hcreate_r>(), B<hsearch_r>() et B<hdestroy_r>() sont des extensions GNU.

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.
fr: L'implémentation des tables de hachage est généralement plus efficace lorsque la table possède assez d'espace libre pour minimiser les collisions. Typiquement, cela signifie que I<nel> devrait être 25\ % plus large que le nombre maximal d'éléments que l'on souhaite enregistrer dans la table.

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.
fr: Les fonctions B<hdestroy>() et B<hdestroy_r>() ne libèrent pas les tampons pointés par les éléments I<key> et I<data> de la table de hachage. Elles ne peuvent pas le faire car elles ne savent pas où ces tampons ont été alloués dynamiquement. Si ces tampons doivent être libérés (peut-être car le programme crée et supprime des tables de hachage de façon répétitive, au lieu de créer un seule table pour toute la vie du programme), alors le programme doit maintenir la liste des tampons libérables.

note: type: SH
en: BUGS
fr: BOGUES

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.
fr: SVr4 et POSIX.1-2001 précisent que I<action> n'est significatif que pour les recherches infructueuses\ ; ainsi B<ENTER> ne devrait avoir aucune influence pour une recherche réussie. Les implémentations libc et glibc (antérieure à la 2.3) ne suivaient pas les spécifications car elles mettaient à jour les données I<data> de la clé I<key> dans ce cas.

note: type: Plain text
en: Individual hash table entries can be added, but not deleted.
fr: Les entrées ne peuvent être qu'ajoutées dans la table, on ne peut pas les supprimer individuellement.

note: type: Plain text
en: The following program inserts 24 items into a hash table, then prints some of them.
fr: Le programme suivant insère 24 éléments dans une table de hachage, puis affiche quelques-uns d'entre eux.

note: type: TH
en: 2010-09-09
fr: 9 septembre 2010

note: type: Plain text
en: insque, remque - insert/remove an item from a queue
fr: insque, remque - Ajouter ou supprimer un élément d'une file

note: type: Plain text
en: Feature Test Macro Requirements for glibc (see B<feature_test_macros>(7)):
fr: Exigences de macros de test de fonctionnalités pour la glibc (consultez B<feature_test_macros>(7)) :

note: type: Plain text
en: B<insque>(), B<remque>():
fr: B<insque>(), B<remque>() :

note: type: Plain text
en: The B<insque>()  and B<remque>()  functions manipulate doubly-linked lists.  Each element in the list is a structure of which the first two elements are a forward and a backward pointer.  The linked list may be linear (i.e., NULL forward pointer at the end of the list and NULL backward pointer at the start of the list)  or circular.
fr: Les fonctions B<insque>() et B<remque>() manipulent une liste doublement chaînée. Chaque élément de cette liste est une structure dont les deux premiers éléments sont des pointeurs avant et arrière. La liste peut être linéaire (c'est-à-dire que l'élément en fin de liste a un pointeur avant à NULL, et l'élément en début de liste a un pointeur arrière à NULL) ou circulaire.

note: type: Plain text
en: The B<insque>()  function inserts the element pointed to by I<elem> immediately after the element pointed to by I<prev>.
fr: B<insque>() insère l'élément pointé par I<elem> immédiatement après l'élément pointé par I<prev>.

note: type: Plain text
en: If the list is linear, then the call I<insque(elem, NULL)> can be used to insert the initial list element, and the call sets the forward and backward pointers of I<elem> to NULL.
fr: Si la liste est linéaire, alors l'appel I<insque(elem, NULL)> peut être utilisé pour insérer l'élément initial de la liste et l'appel définit les pointeurs avant et arrière à NULL.

note: type: Plain text
en: If the list is circular, the caller should ensure that the forward and backward pointers of the first element are initialized to point to that element, and the I<prev> argument of the B<insque>()  call should also point to the element.
fr: Si la liste est circulaire, l'appelant doit s'assurer que les pointeurs avant et arrière du premier élément sont initialisés pour pointer vers cet élément, et que l'argument I<prev> de B<insque>() doit aussi pointer vers cet élément.

note: type: Plain text
en: The B<remque>()  function removes the element pointed to by I<elem> from the doubly-linked list.
fr: B<remque>() supprime l'élément pointé par I<elem> de la liste doublement chaînée.

note: type: Plain text
en: Traditionally (e.g., SunOS, Linux libc 4 and libc 5), the arguments of these functions were of type I<struct qelem *>, defined as:
fr: Traditionnellement (par exemple, SunOS, Linux libc\ 4 et libc 5), les paramètres de ces fonctions sont du type I<struct qelem *>, définie comme ceci\ :

note: type: Plain text
en: struct qelem {
        struct qelem *q_forw;
        struct qelem *q_back;
        char          q_data[1];
    };
fr: struct qelem {
        struct    qelem *q_forw;
        struct    qelem *q_back;
        char      q_data[1];
    };

note: type: Plain text
en: This is still what you will get if B<_GNU_SOURCE> is defined before including I<E<lt>search.hE<gt>>.
fr: C'est ce que vous obtiendrez si B<_GNU_SOURCE> est définie avant l'inclusion de I<E<lt>search.hE<gt>>.

note: type: Plain text
en: The location of the prototypes for these functions differs among several versions of UNIX.  The above is the POSIX version.  Some systems place them in I<E<lt>string.hE<gt>>.  Linux libc4 and libc 5 placed them in I<E<lt>stdlib.hE<gt>>.
fr: L'emplacement des prototypes de ces fonctions varie suivant les différentes versions d'UNIX. Celui précisé ci-dessus correspond à la version POSIX. Certains systèmes les placent dans I<E<lt>string.hE<gt>>. Sous Linux, libc4 et libc5 ils sont renseignés dans I<E<lt>stdlib.hE<gt>>.

note: type: Plain text
en: In glibc 2.4 and earlier, it was not possible to specify I<prev> as NULL.  Consequently, to build a linear list, the caller had to build a list using an initial call that contained the first two elements of the list, with the forward and backward pointers in each element suitably initialized.
fr: Dans la glibc 2.4 et les versions précédentes, il n'était pas possible de spécifier I<prev> à NULL. En conséquence, pour construire une liste linéaire, l'appelant devait construire une liste avec un appel initial contenant les deux premiers éléments de la liste, avec les pointeurs avant et arrière correctement définis pour chaque élément.

note: type: Plain text
en: The program below demonstrates the use of B<insque>().  Here is an example run of the program:
fr: Le programme suivant montre une utilisation de B<insque>(). Ci-dessous la sortie de l'exécution du programme :

note: type: SS
en: Program source
fr: Source du programme

note: type: TH
en: 1999-09-27
fr: 27 septembre 1999

note: type: Plain text
en: lfind, lsearch - linear search of an array
fr: lsearch, lfind - Recherche linéaire dans un tableau

note: type: Plain text
en: B<lfind>()  and B<lsearch>()  perform a linear search for I<key> in the array I<base> which has I<*nmemb> elements of I<size> bytes each.  The comparison function referenced by I<compar> is expected to have two arguments which point to the I<key> object and to an array member, in that order, and which returns zero if the I<key> object matches the array member, and nonzero otherwise.
fr: Les fonctions B<lfind>() et B<lsearch>() effectuent une recherche linéaire de la clé I<key> dans le tableau I<base> contenant I<*nmemb> éléments, chacun de taille I<size> octets. La fonction de comparaison, pointée par I<compar>, est supposée prendre deux arguments pointant sur l'objet I<key> et sur un élément du tableau, dans cet ordre. La fonction de comparaison renvoie zéro si I<key> correspond à cet élément du tableau, et une valeur non nulle sinon.

note: type: Plain text
en: If B<lsearch>()  does not find a matching element, then the I<key> object is inserted at the end of the table, and I<*nmemb> is incremented.  In particular, one should know that a matching element exists, or that more room is available.
fr: Si B<lsearch>() ne trouve pas d'élément correspondant, alors l'objet I<key> est ajouté à la fin du tableau et I<*nmemb> est incrémenté. Il faut savoir qu'un élément de correspondance existe, ou qu'il n'y a plus de place disponible.

note: type: Plain text
en: B<lfind>()  returns a pointer to a matching member of the array, or NULL if no match is found.  B<lsearch>()  returns a pointer to a matching member of the array, or to the newly added member if no match is found.
fr: B<lfind>() renvoie un pointeur sur l'élément du tableau correspondant, ou NULL si aucune correspondance n'est trouvée. B<lsearch>() renvoie un pointeur sur un élément correspondant du tableau, ou sinon sur le nouvel élément ajouté.

note: type: Plain text
en: SVr4, 4.3BSD, POSIX.1-2001.  Present in libc since libc-4.6.27.
fr: SVr4, BSD\ 4.3, POSIX.1-2001. Fonctions présentes dans la libc depuis la version\ 4.6.27.

note: type: Plain text
en: The naming is unfortunate.
fr: L'appellation est malheureuse.

note: type: TH
en: 2012-03-08
fr: 8 mars 2012

note: type: Plain text
en: qsort, qsort_r - sort an array
fr: qsort, qsort_r - Trier un tableau

note: type: Plain text
en: B<qsort_r>(): _GNU_SOURCE
fr: B<qsort_r>() : _GNU_SOURCE

note: type: Plain text
en: The B<qsort>()  function sorts an array with I<nmemb> elements of size I<size>.  The I<base> argument points to the start of the array.
fr: La fonction B<qsort>() trie un tableau contenant I<nmemb> éléments de taille I<size>. L'argument I<base> pointe sur le début du tableau.

note: type: Plain text
en: The contents of the array are sorted in ascending order according to a comparison function pointed to by I<compar>, which is called with two arguments that point to the objects being compared.
fr: Le contenu du tableau est trié en ordre croissant, en utilisant la fonction de comparaison pointée par I<compar>, laquelle est appelée avec deux arguments pointant sur les objets à comparer.

note: type: Plain text
en: The comparison function must return an integer less than, equal to, or greater than zero if the first argument is considered to be respectively less than, equal to, or greater than the second.  If two members compare as equal, their order in the sorted array is undefined.
fr: La fonction de comparaison doit renvoyer un entier inférieur, égal, ou supérieur à zéro si le premier argument est respectivement considéré comme inférieur, égal ou supérieur au second. Si la comparaison des deux arguments renvoie une égalité (valeur de retour nulle), l'ordre des deux éléments est indéfini.

note: type: Plain text
en: The B<qsort_r>()  function is identical to B<qsort>()  except that the comparison function I<compar> takes a third argument.  A pointer is passed to the comparison function via I<arg>.  In this way, the comparison function does not need to use global variables to pass through arbitrary arguments, and is therefore reentrant and safe to use in threads.
fr: La fonction B<qsort_r>() est identique à B<qsort>() si ce n'est que la fonction de comparaison I<compar> prend un troisième argument. Un pointeur est passé à la fonction de comparaison à l'aide de I<arg>. De cette façon, la fonction de comparaison n'a pas besoin d'utiliser des variables globales à passer à l'aide d'arguments arbitraires, et est par conséquent réentrante et sécurisée pour utiliser dans des threads.

note: type: Plain text
en: The B<qsort>()  and B<qsort_r>()  functions return no value.
fr: Les fonction B<qsort>() et B<qsort_r>() ne renvoient pas de valeur.

note: type: Plain text
en: B<qsort_r>()  was added to glibc in version 2.8.
fr: B<qsort_r>() a été ajoutée à la glibc dans la version 2.8.

note: type: Plain text
en: The B<qsort>()  function conforms to SVr4, 4.3BSD, C89, C99.
fr: La fonction B<qsort>() est conforme à SVr4, 4.3BSD, C89 et C99.

note: type: Plain text
en: Library routines suitable for use as the I<compar> argument to B<qsort>()  include B<alphasort>(3)  and B<versionsort>(3).  To compare C strings, the comparison function can call B<strcmp>(3), as shown in the example below.
fr: B<alphasort>(3) et B<versionsort>(3) font partie des routines de bibliothèque utilisables comme argument I<compar> de B<qsort>(). Pour comparer des chaînes de caractères C, la fonction de comparaison peut appeler B<strcmp>(3), comme dans l'exemple ci-dessous.

note: type: Plain text
en: For one example of use, see the example under B<bsearch>(3).
fr: Pour un exemple d'utilisation, voir l'exemple de la page B<bsearch>(3).

note: type: Plain text
en: Another example is the following program, which sorts the strings given in its command-line arguments:
fr: Un autre exemple d'utilisation est le programme ci-dessous, qui trie les chaînes données sur la ligne de commande :

note: type: Plain text
en: static int
    cmpstringp(const void *p1, const void *p2)
    {
        /* The actual arguments to this function are "pointers to
           pointers to char", but strcmp(3) arguments are "pointers
           to char", hence the following cast plus dereference */
fr: static int
    cmpstringp(const void *p1, const void *p2)
    {
        /* Les arguments de cette fonction sont des « pointeurs de
           pointeurs sur des caractères », mais les arguments de
           strcmp(3) sont des « pointeurs sur des caractères », d'où
           le forçage de type et l'utilisation de l'astérisque */

note: type: Plain text
en:     if (argc E<lt> 2) {
            fprintf(stderr, "Usage: %s E<lt>stringE<gt>...\en", argv[0]);
            exit(EXIT_FAILURE);
        }
fr:     if (argc E<lt> 2) {
            fprintf(stderr, "Utilisation : %s E<lt>chaîneE<gt>...\en", argv[0]);
            exit(EXIT_FAILURE);
        }

note: type: Plain text
en: tsearch, tfind, tdelete, twalk, tdestroy - manage a binary tree
fr: tsearch, tfind, tdelete, twalk, tdestroy - Manipuler un arbre binaire

note: type: Plain text
en: B<tsearch>(), B<tfind>(), B<twalk>(), and B<tdelete>()  manage a binary tree.  They are generalized from Knuth (6.2.2) Algorithm T.  The first field in each node of the tree is a pointer to the corresponding data item.  (The calling program must store the actual data.)  I<compar> points to a comparison routine, which takes pointers to two items.  It should return an integer which is negative, zero, or positive, depending on whether the first item is less than, equal to, or greater than the second.
fr: B<tsearch>(), B<tfind>(), B<twalk>() et B<tdelete>() permettent de manipuler un arbre binaire. Ces fonctions implémentent une généralisation de l'algorithme T de Knuth (6.2.2). Le premier membre de chaque nœud de l'arbre est un pointeur vers la donnée elle-même (le programme appelant doit prendre en charge le stockage de ces données). I<compar> pointe sur une routine de comparaison prenant en argument deux pointeurs sur ces données. Elle doit renvoyer un entier négatif, nul, ou positif suivant que le premier élément est inférieur, égal ou supérieur au second.

note: type: Plain text
en: B<tsearch>()  searches the tree for an item.  I<key> points to the item to be searched for.  I<rootp> points to a variable which points to the root of the tree.  If the tree is empty, then the variable that I<rootp> points to should be set to NULL.  If the item is found in the tree, then B<tsearch>()  returns a pointer to it.  If it is not found, then B<tsearch>()  adds it, and returns a pointer to the newly added item.
fr: B<tsearch>() recherche un élément dans l'arbre. I<key> pointe sur l'élément à chercher. I<rootp> pointe vers une variable qui pointe à la racine de l'arbre. Si l'arbre est vide, alors I<rootp> doit pointer sur une variable pointant sur B<NULL>. Si l'élément est trouvé dans l'arbre, B<tsearch>() renvoie un pointeur sur celui-ci. Sinon B<tsearch>() ajoute l'élément dans l'arbre et renvoie un pointeur sur lui.

note: type: Plain text
en: B<tfind>()  is like B<tsearch>(), except that if the item is not found, then B<tfind>()  returns NULL.
fr: B<tfind>() fonctionne comme B<tsearch>(), sauf que si l'élément n'est pas trouvé, la fonction B<tfind>() renvoie B<NULL>.

note: type: Plain text
en: B<tdelete>()  deletes an item from the tree.  Its arguments are the same as for B<tsearch>().
fr: B<tdelete>() supprime un élément de l'arbre. Ses arguments sont les mêmes que ceux de B<tsearch>().

note: type: Plain text
en: B<twalk>()  performs depth-first, left-to-right traversal of a binary tree.  I<root> points to the starting node for the traversal.  If that node is not the root, then only part of the tree will be visited.  B<twalk>()  calls the user function I<action> each time a node is visited (that is, three times for an internal node, and once for a leaf).  I<action>, in turn, takes three arguments.  The first argument is a pointer to the node being visited.  The structure of the node is unspecified, but it is possible to cast the pointer to a pointer-to-pointer-to-element in order to access the element stored within the node.  The application must not modify the structure pointed to by this argument.  The second argument is an integer which takes one of the values B<preorder>, B<postorder>, or B<endorder> depending on whether this is the first, second, or third visit to the internal node, or the value B<leaf> if this is the single visit to a leaf node.  (These symbols are defined in I<E<lt>search.hE<gt>>.)  The third argument is the depth of the node; the root node has depth zero.
fr: B<twalk>() exécute un parcours en profondeur d'abord, de gauche à droite ensuite, de l'arbre binaire. I<root> pointe sur le nœud de départ du parcours. S'il ne s'agit pas de la vraie racine de l'arbre, seule une partie de celui-ci sera balayée. B<twalk>() appelle la fonction I<action> chaque fois qu'un nœud est rencontré (c'est-à-dire trois fois pour un nœud interne et une seule fois pour une feuille de l'arbre). I<action> doit accepter trois arguments. Le premier argument est un pointeur sur le nœud rencontré. La structure du nœud n'est pas spécifiée, mais il est possible transformer le pointeur sous forme de pointeur-vers-pointeur-vers-élément afin d'accéder à l'élément enregistré dans le nœud. L'application ne doit pas modifier la structure pointée par cet argument. Le deuxième argument est un entier prenant l'une des valeurs suivantes\ : B<preorder>, B<postorder> ou B<endorder> suivant qu'il s'agisse de la première, deuxième ou troisième rencontre du nœud, ou la valeur B<leaf> s'il s'agit d'un nœud feuille (ces symboles sont définis dans I<E<lt>search.hE<gt>>). Le troisième argument est la profondeur du nœud dans l'arbre, le nœud racine ayant la profondeur zéro.

note: type: Plain text
en: (More commonly, B<preorder>, B<postorder>, and B<endorder> are known as B<preorder>, B<inorder>, and B<postorder>: before visiting the children, after the first and before the second, and after visiting the children.  Thus, the choice of name B<post\%order> is rather confusing.)
fr: Ordinairement, B<preorder>, B<postorder> et B<endorder> sont connus sous le nom B<preorder> (préfixe), B<inorder> (infixe), et B<postorder> (postfixe)\ : avant de visiter le nœud fils, après le premier et avant le second, après avoir visité les enfants. Ainsi, le choix du nom B<post\%order> est un peu déroutant.

note: type: Plain text
en: B<tdestroy>()  removes the whole tree pointed to by I<root>, freeing all resources allocated by the B<tsearch>()  function.  For the data in each tree node the function I<free_node> is called.  The pointer to the data is passed as the argument to the function.  If no such work is necessary, I<free_node> must point to a function doing nothing.
fr: B<tdestroy>() supprime tout l'arbre pointé par I<root>, libérant toutes les ressources allouées par la fonction B<tsearch>(). Pour libérer les données de chaque nœud, la fonction I<free_node> est invoquée. Le pointeur sur les données est passé en argument à cette fonction. Si aucune libération n'est nécessaire, I<free_node> doit pointer vers une fonction ne faisant rien.

note: type: Plain text
en: B<tsearch>()  returns a pointer to a matching item in the tree, or to the newly added item, or NULL if there was insufficient memory to add the item.  B<tfind>()  returns a pointer to the item, or NULL if no match is found.  If there are multiple elements that match the key, the element returned is unspecified.
fr: B<tsearch>() renvoie un pointeur sur un élément correspondant de l'arbre, sur l'élément nouvellement ajouté, ou B<NULL> s'il n'y avait pas assez de mémoire pour ajouter le nœud. B<tfind>() renvoie un pointeur sur l'élément recherché ou B<NULL> si aucune correspondance n'a été trouvée. Si plusieurs éléments correspondent à la clé, celui renvoyé n'est pas spécifié.

note: type: Plain text
en: B<tdelete>()  returns a pointer to the parent of the item deleted, or NULL if the item was not found.
fr: B<tdelete>() renvoie un pointeur sur le nœud père de celui détruit, ou B<NULL> si l'élément n'a pas été trouvé.

note: type: Plain text
en: B<tsearch>(), B<tfind>(), and B<tdelete>()  also return NULL if I<rootp> was NULL on entry.
fr: B<tsearch>(), B<tfind>() et B<tdelete>() renvoient également B<NULL> si I<rootp> valait B<NULL>.

note: type: Plain text
en: SVr4, POSIX.1-2001.  The function B<tdestroy>()  is a GNU extension.
fr: SVr4, POSIX.1-2001. La fonction B<tdestroy>() est une extension GNU.

note: type: Plain text
en: B<twalk>()  takes a pointer to the root, while the other functions take a pointer to a variable which points to the root.
fr: B<twalk>() utilise un pointeur sur la racine, alors que les autres fonctions utilisent un pointeur sur une variable pointant sur la racine.

note: type: Plain text
en: B<tdelete>()  frees the memory required for the node in the tree.  The user is responsible for freeing the memory for the corresponding data.
fr: B<tdelete>() libère la mémoire nécessaire au stockage du nœud dans l'arbre. Le programme appelant est responsable de la libération de la mémoire occupée par l'élément de donnée correspondant.

note: type: Plain text
en: The example program depends on the fact that B<twalk>()  makes no further reference to a node after calling the user function with argument "endorder" or "leaf".  This works with the GNU library implementation, but is not in the System V documentation.
fr: Le programme d'exemple s'appuie sur le fait que B<twalk>() ne fait plus jamais référence à un nœud après avoir appelé la fonction utilisateur avec l'argument «\ endorder\ » ou «\ leaf\ ». Ceci fonctionne avec l'implémentation de la bibliothèque GNU, mais n'est pas spécifié sous System V.

note: type: Plain text
en: The following program inserts twelve random numbers into a binary tree, where duplicate numbers are collapsed, then prints the numbers in order.
fr: Le programme suivant insère douze nombres aléatoires dans un arbre binaire, où les doublons sont supprimés, puis affiche les nombres classés.

note: type: Plain text
en: #define _GNU_SOURCE     /* Expose declaration of tdestroy() */
    #include E<lt>search.hE<gt>
    #include E<lt>stdlib.hE<gt>
    #include E<lt>stdio.hE<gt>
    #include E<lt>time.hE<gt>
fr: #define _GNU_SOURCE     /* Expose la déclaration de tdestroy() */
    #include E<lt>search.hE<gt>
    #include E<lt>stdlib.hE<gt>
    #include E<lt>stdio.hE<gt>
    #include E<lt>time.hE<gt>

note: type: Plain text
en: static void *root = NULL;
fr: static void *racine = NULL;

note: type: Plain text
en: static void *
    xmalloc(unsigned n)
    {
        void *p;
        p = malloc(n);
        if (p)
            return p;
        fprintf(stderr, "insufficient memory\en");
        exit(EXIT_FAILURE);
    }
fr: static void *
    xmalloc(unsigned n)
    {
        void *p;
        p = malloc(n);
        if (p)
            return p;
        fprintf(stderr, "pas assez de mémoire\en");
        exit(EXIT_FAILURE);
    }

note: type: Plain text
en: static void
    action(const void *nodep, const VISIT which, const int depth)
    {
        int *datap;
fr: static void
    action(const void *nodep, const VISIT type, const int prof)
    {
        int *datap;

note: type: Plain text
en:     switch (which) {
        case preorder:
            break;
        case postorder:
            datap = *(int **) nodep;
            printf("%6d\en", *datap);
            break;
        case endorder:
            break;
        case leaf:
            datap = *(int **) nodep;
            printf("%6d\en", *datap);
            break;
        }
    }
fr:     switch (type) {
        case preorder:
            break;
        case postorder:
            datap = *(int **) nodep;
            printf("%6d\en", *datap);
            break;
        case endorder:
            break;
        case leaf:
            datap = *(int **) nodep;
            printf("%6d\en", *datap);
            break;
        }
    }
