glibc 中队列的使用

今天看 DPDK 源码时,发现它使用了 glibc 中提供的队列 API,这些 API 包含在 <sys/queue.h> 头文件中,易于使用。
今天看了下 man 手册,记录下如何使用这些 API 。

第一种队列是 singly-linked lists。单向链表,插入操作只支持向头部插入,所以通常用来实现 LIFO(后进先出队列)。

第二种队列是 singly-linked tail queues。单向链表,新增了向尾部的插入操作,所以通常用来实现 FIFO(先进先出队列)。

第三种是 lists 。双向链表,插入操作只支持向头部插入。支持双向遍历。

第四种是 tail queues。双向链表,插入操作支持向头部和尾部的插入。支持双向遍历。

下面以 singly-linked lists 为例,介绍如何使用这些 API。

首先要定义一个结构体,例子中使用的结构体名称为 “entry” ,里面除了包含自定义的数据成员(val)外,还必须包含使用 SLIST_ENTRY(TYPE) 定义的一个成员。TYPE 必须是结构体名称 “entry”,成员名称为“entries”可以任意取名。这样我们这个数据结构就能够使用链表 API 管理了。如下所示:

struct entry {
    /* 数据 */
    int val;
    SLIST_ENTRY(entry) entries;     /* Singly-linked List. */
}

接着使用 SLIST_HEAD(HEADNAME, TYPE) 定义一个作为链表头部的新结构体,HEADNAME 是新结构体名称,TYPE 是我们自定义的结构体名称。如下所示,例子中使用的新结构体名称为“slisthead”:

SLIST_HEAD(slisthead, entry);

然后定义一个链表头部变量,并初始化:

struct slisthead head = SLIST_HEAD_INITIALIZER(head);
SLIST_INIT(&head);

接下来就可以使用 API 将数据插入到链表了,具体请看下面的个例子。

singly-linked lists

#include <stdio.h>
#include <stdlib.h>
#include <sys/queue.h>

int main(int argc, char **argv)
{
     SLIST_HEAD(slisthead, entry) head = SLIST_HEAD_INITIALIZER(head);
     struct slisthead *headp;                /* Singly-linked List head. */
     struct entry {
             int val;
             SLIST_ENTRY(entry) entries;     /* Singly-linked List. */
     } *n1, *n2, *n3, *np;

     SLIST_INIT(&head);                      /* Initialize the list. */

     n1 = malloc(sizeof(struct entry));      /* Insert at the head. */
     SLIST_INSERT_HEAD(&head, n1, entries);

     n2 = malloc(sizeof(struct entry));      /* Insert after. */
     SLIST_INSERT_AFTER(n1, n2, entries);

     SLIST_FOREACH(np, &head, entries) {     /* Forward traversal. */
        printf("val = %d\n", np->val);
     }
     
     SLIST_REMOVE(&head, n2, entry, entries);/* Deletion. */
     free(n2);

     n3 = SLIST_FIRST(&head);
     SLIST_REMOVE_HEAD(&head, entries);      /* Deletion from the head. */
     free(n3);
                                             

     while (!SLIST_EMPTY(&head)) {           /* List Deletion. */
             n1 = SLIST_FIRST(&head);
             SLIST_REMOVE_HEAD(&head, entries);
             free(n1);
     }
}

singly-linked tail queues

#include <stdio.h>
#include <stdlib.h>
#include <sys/queue.h>

int main(int argc, char **argv)
{
     STAILQ_HEAD(stailhead, entry) head = STAILQ_HEAD_INITIALIZER(head);
     struct stailhead *headp;                /* Singly-linked tail queue head. */
     struct entry {
             int val;
             STAILQ_ENTRY(entry) entries;    /* Tail queue. */
     } *n1, *n2, *n3, *np;

     STAILQ_INIT(&head);                     /* Initialize the queue. */

     n1 = malloc(sizeof(struct entry));      /* Insert at the head. */
     STAILQ_INSERT_HEAD(&head, n1, entries);

     n1 = malloc(sizeof(struct entry));      /* Insert at the tail. */
     STAILQ_INSERT_TAIL(&head, n1, entries);

     n2 = malloc(sizeof(struct entry));      /* Insert after. */
     STAILQ_INSERT_AFTER(&head, n1, n2, entries);
                                             /* Deletion. */
     STAILQ_REMOVE(&head, n2, entry, entries);
     free(n2);
                                             /* Deletion from the head. */
     n3 = STAILQ_FIRST(&head);
     STAILQ_REMOVE_HEAD(&head, entries);
     free(n3);
                                             /* Forward traversal. */
     STAILQ_FOREACH(np, &head, entries) {
            printf("val = %d\n", np->val);
     }
                                             /* TailQ Deletion. */
     while (!STAILQ_EMPTY(&head)) {
             n1 = STAILQ_FIRST(&head);
             STAILQ_REMOVE_HEAD(&head, entries);
             free(n1);
     }
                                             /* Faster TailQ Deletion. */
     n1 = STAILQ_FIRST(&head);
     while (n1 != NULL) {
             n2 = STAILQ_NEXT(n1, entries);
             free(n1);
             n1 = n2;
     }
     STAILQ_INIT(&head);

}

lists

#include <stdio.h>
#include <stdlib.h>
#include <sys/queue.h>

int main(int argc, char **argv)
{
     LIST_HEAD(listhead, entry) head =
         LIST_HEAD_INITIALIZER(head);
     struct listhead *headp;                 /* List head. */
     struct entry {
             int val;
             LIST_ENTRY(entry) entries;      /* List. */
     } *n1, *n2, *n3, *np, *np_temp;

     LIST_INIT(&head);                       /* Initialize the list. */

     n1 = malloc(sizeof(struct entry));      /* Insert at the head. */
     LIST_INSERT_HEAD(&head, n1, entries);

     n2 = malloc(sizeof(struct entry));      /* Insert after. */
     LIST_INSERT_AFTER(n1, n2, entries);

     n3 = malloc(sizeof(struct entry));      /* Insert before. */
     LIST_INSERT_BEFORE(n2, n3, entries);

     LIST_REMOVE(n2, entries);               /* Deletion. */
     free(n2);
                                             /* Forward traversal. */
     LIST_FOREACH(np, &head, entries) {
             printf("val = %d\n", np->val);
     }

     while (!LIST_EMPTY(&head)) {            /* List Deletion. */
             n1 = LIST_FIRST(&head);
             LIST_REMOVE(n1, entries);
             free(n1);
     }

     n1 = LIST_FIRST(&head);                 /* Faster List Deletion. */
     while (n1 != NULL) {
             n2 = LIST_NEXT(n1, entries);
             free(n1);
             n1 = n2;
     }
     LIST_INIT(&head);
}

tail queues

#include <stdio.h>
#include <stdlib.h>
#include <sys/queue.h>

int main(int argc, char **argv)
{
     TAILQ_HEAD(tailhead, entry) head = TAILQ_HEAD_INITIALIZER(head);
     struct tailhead *headp;                 /* Tail queue head. */
     struct entry {
             int val;
             TAILQ_ENTRY(entry) entries;     /* Tail queue. */
     } *n1, *n2, *n3, *np;

     TAILQ_INIT(&head);                      /* Initialize the queue. */

     n1 = malloc(sizeof(struct entry));      /* Insert at the head. */
     n1->val = 1;
     TAILQ_INSERT_HEAD(&head, n1, entries);

     n1 = malloc(sizeof(struct entry));      /* Insert at the tail. */
     n1->val = 2;
     TAILQ_INSERT_TAIL(&head, n1, entries);

     n2 = malloc(sizeof(struct entry));      /* Insert after. */
     n2->val = 3;
     TAILQ_INSERT_AFTER(&head, n1, n2, entries);

     n3 = malloc(sizeof(struct entry));      /* Insert before. */
     n3->val = 4;
     TAILQ_INSERT_BEFORE(n2, n3, entries);

     TAILQ_REMOVE(&head, n2, entries);       /* Deletion. */
     free(n2);
                                             /* Forward traversal. */
     TAILQ_FOREACH(np, &head, entries) {
             printf("val = %d\n", np->val);
     }
                                             /* Reverse traversal. */
     TAILQ_FOREACH_REVERSE(np, &head, tailhead, entries) {
             printf("val = %d\n", np->val);
     }
                                             /* TailQ Deletion. */
     while (!TAILQ_EMPTY(&head)) {
             n1 = TAILQ_FIRST(&head);
             TAILQ_REMOVE(&head, n1, entries);
             free(n1);
     }
                                             /* Faster TailQ Deletion. */
     n1 = TAILQ_FIRST(&head);
     while (n1 != NULL) {
             n2 = TAILQ_NEXT(n1, entries);
             free(n1);
             n1 = n2;
     }

     TAILQ_INIT(&head);
}
发布了113 篇原创文章 · 获赞 53 · 访问量 31万+
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 技术工厂 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览