Provided by: manpages-fr-dev_3.57d1p1-1_all bug

NOM

       LIST_ENTRY,   LIST_HEAD,   LIST_INIT,  LIST_INSERT_AFTER,  LIST_INSERT_HEAD,  LIST_REMOVE,
       TAILQ_ENTRY,    TAILQ_HEAD,     TAILQ_INIT,     TAILQ_INSERT_AFTER,     TAILQ_INSERT_HEAD,
       TAILQ_INSERT_TAIL,     TAILQ_REMOVE,     CIRCLEQ_ENTRY,     CIRCLEQ_HEAD,    CIRCLEQ_INIT,
       CIRCLEQ_INSERT_AFTER,  CIRCLEQ_INSERT_BEFORE,  CIRCLEQ_INSERT_HEAD,   CIRCLEQ_INSERT_TAIL,
       CIRCLEQ_REMOVE - Implementations des listes, listes doubles et circulaires

SYNOPSIS

       #include <sys/queue.h>

       LIST_ENTRY(TYPE);
       LIST_HEAD(HEADNAME, TYPE);
       LIST_INIT(LIST_HEAD *head);
       LIST_INSERT_AFTER(LIST_ENTRY *listelm,
                       TYPE *elm, LIST_ENTRY NAME);
       LIST_INSERT_HEAD(LIST_HEAD *head,
                       TYPE *elm, LIST_ENTRY NAME);
       LIST_REMOVE(TYPE *elm, LIST_ENTRY NAME);

       TAILQ_ENTRY(TYPE);
       TAILQ_HEAD(HEADNAME, TYPE);
       TAILQ_INIT(TAILQ_HEAD *head);
       TAILQ_INSERT_AFTER(TAILQ_HEAD *head, TYPE *listelm,
                       TYPE *elm, TAILQ_ENTRY NAME);
       TAILQ_INSERT_HEAD(TAILQ_HEAD *head,
                       TYPE *elm, TAILQ_ENTRY NAME);
       TAILQ_INSERT_TAIL(TAILQ_HEAD *head,
                       TYPE *elm, TAILQ_ENTRY NAME);
       TAILQ_REMOVE(TAILQ_HEAD *head, TYPE *elm, TAILQ_ENTRY NAME);

       CIRCLEQ_ENTRY(TYPE);
       CIRCLEQ_HEAD(HEADNAME, TYPE);
       CIRCLEQ_INIT(CIRCLEQ_HEAD *head);
       CIRCLEQ_INSERT_AFTER(CIRCLEQ_HEAD *head, TYPE *listelm,
                       TYPE *elm, CIRCLEQ_ENTRY NAME);
       CIRCLEQ_INSERT_BEFORE(CIRCLEQ_HEAD *head, TYPE *listelm,
                       TYPE *elm, CIRCLEQ_ENTRY NAME);
       CIRCLEQ_INSERT_HEAD(CIRCLEQ_HEAD *head,
                       TYPE *elm, CIRCLEQ_ENTRY NAME);
       CIRCLEQ_INSERT_TAIL(CIRCLEQ_HEAD *head,
                       TYPE *elm, CIRCLEQ_ENTRY NAME);
       CIRCLEQ_REMOVE(CIRCLEQ_HEAD *head,
                       TYPE *elm, CIRCLEQ_ENTRY NAME);

DESCRIPTION

       Ces  macros  définissent  et  manipulent trois types de structures de données : les listes
       simples, les listes doubles et les listes circulaires. Ces trois structures supportent les
       fonctionnalités suivantes :

           *   Insertion d'un élément en tête de liste ;
           *   Insertion d'un élément après n'importe quel élément existant ;
           *   Suppression de n'importe quel élément ;
           *   Traversée séquentielle de la liste.

       Les  listes  sont les plus simples de ces trois structures de données et ne supportent que
       les fonctionnalités ci-dessus.

       Les listes doubles ajoutent la fonctionnalité suivante :

           *   Un élément peut être ajouté en fin de liste.

       Cependant :

           1.  Toutes les insertions et suppressions doivent mentionner la tête de la liste ;
           2.  L'élément de tête nécessite deux pointeurs au lieu d'un seul ;
           3.  La taille du code est environ 15% plus grande, et  l'exécution  environ  20%  plus
               lente que les listes.

       Les listes circulaires ajoutent les fonctionnalités suivantes :

           *   Un élément peut être ajouté en fin de liste.
           *   Des entrées peuvent être ajoutées avant chaque entrée ;
           *   Elles peuvent être traversées à l'envers, de la queue à la tête ;

       Cependant :

           1.  Toutes les insertions et suppressions doivent mentionner la tête de la liste ;
           2.  L'élément de tête nécessite deux pointeurs au lieu d'un seul ;
           3.  La condition de terminaison pour la traversée est plus compliquée ;
           4.  La  taille  du  code  est environ 40% plus grande, et l'exécution environ 45% plus
               lente que les listes.

       Dans les définitions de macros, TYPE est le nom d'une structure définie par l'utilisateur,
       qui  doit contenir un champ de type LIST_ENTRY, TAILQ_ENTRY ou CIRCLEQ_ENTRY, appelé NAME.
       L'argument HEADNAME est le nom d'une structure définie par  l'utilisateur  qui  doit  être
       déclarée  en  utilisant  les  macros  LIST_HEAD, TAILQ_HEAD ou CIRCLEQ_HEAD. Consultez les
       exemples plus bas pour une explication sur l'utilisation de ces macros.

   Listes
       Une liste débute par une  structure  définie  par  la  macro  LIST_HEAD.  Cette  structure
       contient  un  pointeur  simple  sur  le  premier  élément  de  la liste. Les éléments sont
       doublement chaînés afin qu'un élément puisse être supprimé sans parcourir toute la  liste.
       Des  éléments  peuvent  être  ajoutés  après  un élément existant ou en tête de liste. Une
       structure LIST_HEAD est déclarée ainsi :

           LIST_HEAD(HEADNAME, TYPE) head;

       où HEADNAME est le nom de la structure à définir, et TYPE le type d'élément à lier dans la
       liste. Un pointeur sur la tête de la liste peut ensuite être déclaré ainsi :

           struct HEADNAME *headp;

       (les noms head et headp sont choisis par l'utilisateur)

       La macro LIST_ENTRY déclare une structure qui connecte les éléments dans la liste.

       La macro LIST_INIT initialise la liste référencée par head.

       La macro LIST_INSERT_HEAD insère le nouvel élément elm à la tête de la liste.

       La macro LIST_INSERT_AFTER insère le nouvel élément elm après l'élément listelm.

       La macro LIST_REMOVE supprime l'élément elm de la liste.

   Exemple de liste
       LIST_HEAD(listhead, entry) head;
       struct listhead *headp;                 /* Tête de la liste */
       struct entry {
           ...
           LIST_ENTRY(entry) entries;          /* Liste */
           ...
       } *n1, *n2, *np;

       LIST_INIT(&head);                       /* Initialisation de liste */

       n1 = malloc(sizeof(struct entry));      /* Insertion en tête */
       LIST_INSERT_HEAD(&head, n1, entries);

       n2 = malloc(sizeof(struct entry));      /* Insertion après */
       LIST_INSERT_AFTER(n1, n2, entries);
                                               /* Parcours en avant */
       for (np = head.lh_first; np != NULL; np = np->entries.le_next)
           np-> ...

       while (head.lh_first != NULL)           /* Suppression */
           LIST_REMOVE(head.lh_first, entries);

   Listes doubles
       La tête d'une liste double est désignée par une structure définie par la macro TAILQ_HEAD.
       Cette structure contient deux pointeurs, l'un sur le premier élément  et  l'autre  sur  le
       dernier  élément.  Les  éléments sont doublement chaînés, ainsi un élément quelconque peut
       être supprimé sans reparcourir toute la liste. Les nouveaux éléments peuvent être  ajoutés
       après  un  élément  existant,  en  tête ou en queue de liste. Une structure TAILQ_HEAD est
       déclarée ainsi :

           TAILQ_HEAD(HEADNAME, TYPE) head;

       où HEADNAME est le nom de la structure à définir, et TYPE représente le type des  éléments
       à lier dans la liste. Un pointeur sur la tête de la liste peut être déclaré ainsi :

           struct HEADNAME *headp;

       (les noms head et headp sont choisis par l'utilisateur)

       La macro TAILQ_ENTRY déclare une structure qui connecte les éléments dans la liste double.

       La macro TAILQ_INIT initialise la liste double référencée par head.

       La macro TAILQ_INSERT_HEAD insère le nouvel élément elm à la fin de la liste double.

       La macro TAILQ_INSERT_TAIL insère le nouvel élément elm à la fin de la liste double.

       La macro TAILQ_INSERT_AFTER insère le nouvel élément elm après l'élément listelm.

       La macro TAILQ_REMOVE supprime l'élément elm de la liste double.

   Exemple de liste double
       TAILQ_HEAD(tailhead, entry) head;
       struct tailhead *headp;                 /* Tête de liste double */
       struct entry {
           ...
           TAILQ_ENTRY(entry) entries;         /* Liste double */
           ...
       } *n1, *n2, *np;

       TAILQ_INIT(&head);                      /* Initialisation de liste */

       n1 = malloc(sizeof(struct entry));      /* Insertion au début */
       TAILQ_INSERT_HEAD(&head, n1, entries);

       n1 = malloc(sizeof(struct entry));      /* Insertion à la fin */
       TAILQ_INSERT_TAIL(&head, n1, entries);

       n2 = malloc(sizeof(struct entry));      /* Insertion après */
       TAILQ_INSERT_AFTER(&head, n1, n2, entries);
                                               /* Parcours en avant */
       for (np = head.tqh_first; np != NULL; np = np->entries.tqe_next)
           np-> ...
                                               /* Suppression */
       while (head.tqh_first != NULL)
           TAILQ_REMOVE(&head, head.tqh_first, entries);

   Listes circulaires
       La  tête  d'une  liste  circulaire  est  désignée  par  une structure définie par la macro
       CIRCLEQ_HEAD. Cette structure contient une paire de pointeurs, l'un sur le premier élément
       de  la  liste  circulaire  et l'autre sur le dernier élément. Les éléments sont doublement
       chaînés, afin de pouvoir supprimer un élément quelconque sans reparcourir toute la  liste.
       De  nouveaux éléments peuvent être ajoutés avant ou après un élément existant, au début ou
       à la fin de la liste. Une structure CIRCLEQ_HEAD est déclarée ainsi :

           CIRCLEQ_HEAD(HEADNAME, TYPE) head;

       où HEADNAME est le nom de la structure à définir, et TYPE est le type de l'élément à  lier
       dans la liste circulaire. Un pointeur sur la tête de la liste circulaire peut être déclaré
       ainsi :

           struct HEADNAME *headp;

       (les noms head et headp sont choisis par l'utilisateur)

       La macro CIRCLEQ_ENTRY déclare une structure qui  connecte  les  éléments  dans  la  liste
       circulaire.

       La macro CIRCLEQ_INIT initialise la liste circulaire référencée par head.

       La macro CIRCLEQ_INSERT_HEAD insère le nouvel élément elm au début de la liste circulaire.

       La macro CIRCLEQ_INSERT_TAIL insère le nouvel élément elm à la fin de la liste circulaire.

       La macro CIRCLEQ_INSERT_AFTER insère le nouvel élément elm après l'élément listelm.

       La macro CIRCLEQ_INSERT_BEFORE insère le nouvel élément elm avant l'élément listelm.

       La macro CIRCLEQ_REMOVE supprime l'élément elm de la liste circulaire.

   Exemple de liste circulaire
       CIRCLEQ_HEAD(circleq, entry) head;
       struct circleq *headp;              /* Tête de liste circulaire */
       struct entry {
           ...
           CIRCLEQ_ENTRY(entry) entries;   /* Liste circulaire */
           ...
       } *n1, *n2, *np;

       CIRCLEQ_INIT(&head);                /* Initialisation */

       n1 = malloc(sizeof(struct entry));  /* Insertion au début */
       CIRCLEQ_INSERT_HEAD(&head, n1, entries);

       n1 = malloc(sizeof(struct entry));  /* Insertion à la fin */
       CIRCLEQ_INSERT_TAIL(&head, n1, entries);

       n2 = malloc(sizeof(struct entry));  /* Insertion après */
       CIRCLEQ_INSERT_AFTER(&head, n1, n2, entries);

       n2 = malloc(sizeof(struct entry));  /* Insertion avant */
       CIRCLEQ_INSERT_BEFORE(&head, n1, n2, entries);
                                           /* Parcours en avant */
       for (np = head.cqh_first; np != (void *)&head;
               np = np->entries.cqe_next)
           np-> ...
                                           /* Parcours en arrière */
       for (np = head.cqh_last; np != (void *)&head; np = np->entries.cqe_prev)
           np-> ...
                                           /* Suppression */
       while (head.cqh_first != (void *)&head)
           CIRCLEQ_REMOVE(&head, head.cqh_first, entries);

CONFORMITÉ

       Pas  dans  POSIX.1-2001. Présentes sur les BSD. Les fonctions de liste queue sont apparues
       dans BSD 4.4.

COLOPHON

       Cette page fait partie de la publication 3.57 du projet 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/.

TRADUCTION

       Depuis   2010,   cette   traduction   est   maintenue   à   l'aide   de    l'outil    po4a
       <http://po4a.alioth.debian.org/>  par l'équipe de traduction francophone au sein du projet
       perkamon <http://perkamon.alioth.debian.org/>.

       Christophe   Blaess   <http://www.blaess.fr/christophe/>   (1996-2003),    Alain    Portal
       <http://manpagesfr.free.fr/>  (2003-2006).  Nicolas  François  et  l'équipe francophone de
       traduction de Debian (2006-2009).

       Veuillez     signaler     toute     erreur     de     traduction     en     écrivant     à
       <debian-l10n-french@lists.debian.org>   ou   par   un  rapport  de  bogue  sur  le  paquet
       manpages-fr.

       Vous pouvez toujours avoir accès à la version anglaise de  ce  document  en  utilisant  la
       commande « man -L C <section> <page_de_man> ».