TAILQ练习的一个例子

最新推荐文章于 2022-03-04 09:34:02 发布
最新推荐文章于 2022-03-04 09:34:02 发布
阅读量203 收藏
点赞数
分类专栏： C语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/daa20/article/details/113442520
版权

queue.h:

/*
 * List definitions.
 */
#define LIST_HEAD(name, type)                                           \
struct name {                                                           \
        struct type *lh_first;  /* first element */                     \
}

#define LIST_HEAD_INITIALIZER(head)                                     \
        { NULL }

#define LIST_ENTRY(type)                                                \
struct {                                                                \
        struct type *le_next;   /* next element */                      \
        struct type **le_prev;  /* address of previous next element */  \
}

/*
 * List functions.
 */
#if defined(_KERNEL) && defined(QUEUEDEBUG)
#define QUEUEDEBUG_LIST_INSERT_HEAD(head, elm, field)                   \
        if ((head)->lh_first &&                                         \
            (head)->lh_first->field.le_prev != &(head)->lh_first)       \
                panic("LIST_INSERT_HEAD %p %s:%d", (head), __FILE__, __LINE__);
#define QUEUEDEBUG_LIST_OP(elm, field)                                  \
        if ((elm)->field.le_next &&                                     \
            (elm)->field.le_next->field.le_prev !=                      \
            &(elm)->field.le_next)                                      \
                panic("LIST_* forw %p %s:%d", (elm), __FILE__, __LINE__);\
        if (*(elm)->field.le_prev != (elm))                             \
                panic("LIST_* back %p %s:%d", (elm), __FILE__, __LINE__);
#define QUEUEDEBUG_LIST_POSTREMOVE(elm, field)                          \
        (elm)->field.le_next = (void *)1L;                              \
        (elm)->field.le_prev = (void *)1L;
#else
#define QUEUEDEBUG_LIST_INSERT_HEAD(head, elm, field)
#define QUEUEDEBUG_LIST_OP(elm, field)
#define QUEUEDEBUG_LIST_POSTREMOVE(elm, field)
#endif

#define LIST_INIT(head) do {                                            \
        (head)->lh_first = NULL;                                        \
} while (/*CONSTCOND*/0)

#define LIST_INSERT_AFTER(listelm, elm, field) do {                     \
        QUEUEDEBUG_LIST_OP((listelm), field)                            \
        if (((elm)->field.le_next = (listelm)->field.le_next) != NULL)  \
                (listelm)->field.le_next->field.le_prev =               \
                    &(elm)->field.le_next;                              \
        (listelm)->field.le_next = (elm);                               \
        (elm)->field.le_prev = &(listelm)->field.le_next;               \
} while (/*CONSTCOND*/0)

#define LIST_INSERT_BEFORE(listelm, elm, field) do {                    \
        QUEUEDEBUG_LIST_OP((listelm), field)                            \
        (elm)->field.le_prev = (listelm)->field.le_prev;                \
        (elm)->field.le_next = (listelm);                               \
        *(listelm)->field.le_prev = (elm);                              \
        (listelm)->field.le_prev = &(elm)->field.le_next;               \
} while (/*CONSTCOND*/0)

#define LIST_INSERT_HEAD(head, elm, field) do {                         \
        QUEUEDEBUG_LIST_INSERT_HEAD((head), (elm), field)               \
        if (((elm)->field.le_next = (head)->lh_first) != NULL)          \
                (head)->lh_first->field.le_prev = &(elm)->field.le_next;\
        (head)->lh_first = (elm);                                       \
        (elm)->field.le_prev = &(head)->lh_first;                       \
} while (/*CONSTCOND*/0)

#define LIST_REMOVE(elm, field) do {                                    \
        QUEUEDEBUG_LIST_OP((elm), field)                                \
        if ((elm)->field.le_next != NULL)                               \
                (elm)->field.le_next->field.le_prev =                   \
                    (elm)->field.le_prev;                               \
        *(elm)->field.le_prev = (elm)->field.le_next;                   \
        QUEUEDEBUG_LIST_POSTREMOVE((elm), field)                        \
} while (/*CONSTCOND*/0)

#define LIST_FOREACH(var, head, field)                                  \
        for ((var) = ((head)->lh_first);                                \
                (var);                                                  \
                (var) = ((var)->field.le_next))

/*
 * List access methods.
 */
#define LIST_EMPTY(head)                ((head)->lh_first == NULL)
#define LIST_FIRST(head)                ((head)->lh_first)
#define LIST_NEXT(elm, field)           ((elm)->field.le_next)

/*
 * Singly-linked List definitions.
 */
#define SLIST_HEAD(name, type)                                          \
struct name {                                                           \
        struct type *slh_first; /* first element */                     \
}

#define SLIST_HEAD_INITIALIZER(head)                                    \
        { NULL }

#define SLIST_ENTRY(type)                                               \
struct {                                                                \
        struct type *sle_next;  /* next element */                      \
}

/*
 * Singly-linked List functions.
 */
#define SLIST_EMPTY(head)       ((head)->slh_first == NULL)
#define SLIST_FIRST(head)       ((head)->slh_first)
#define SLIST_NEXT(elm, field)  ((elm)->field.sle_next)

#define SLIST_FOREACH(var, head, field)                                 \
        for((var) = (head)->slh_first; (var); (var) = (var)->field.sle_next)

#define SLIST_INIT(head) do {                                           \
        (head)->slh_first = NULL;                                       \
} while (/*CONSTCOND*/0)

#define SLIST_INSERT_AFTER(slistelm, elm, field) do {                   \
        (elm)->field.sle_next = (slistelm)->field.sle_next;             \
        (slistelm)->field.sle_next = (elm);                             \
} while (/*CONSTCOND*/0)

#define SLIST_INSERT_HEAD(head, elm, field) do {                        \
        (elm)->field.sle_next = (head)->slh_first;                      \
        (head)->slh_first = (elm);                                      \
} while (/*CONSTCOND*/0)

#define SLIST_NEXT(elm, field)  ((elm)->field.sle_next)

#define SLIST_REMOVE_HEAD(head, field) do {                             \
        (head)->slh_first = (head)->slh_first->field.sle_next;          \
} while (/*CONSTCOND*/0)

#define SLIST_REMOVE(head, elm, type, field) do {                       \
        if ((head)->slh_first == (elm)) {                               \
                SLIST_REMOVE_HEAD((head), field);                       \
        }                                                               \
        else {                                                          \
                struct type *curelm = (head)->slh_first;                \
                while(curelm->field.sle_next != (elm))                  \
                        curelm = curelm->field.sle_next;                \
                curelm->field.sle_next =                                \
                    curelm->field.sle_next->field.sle_next;             \
        }                                                               \
} while (/*CONSTCOND*/0)

/*
 * Singly-linked Tail queue declarations.
 */
#define STAILQ_HEAD(name, type)                                 \
struct name {                                                           \
        struct type *stqh_first;        /* first element */                     \
        struct type **stqh_last;        /* addr of last next element */         \
}

#define STAILQ_HEAD_INITIALIZER(head)                                   \
        { NULL, &(head).stqh_first }

#define STAILQ_ENTRY(type)                                              \
struct {                                                                \
        struct type *stqe_next; /* next element */                      \
}

/*
 * Singly-linked Tail queue functions.
 */
#define STAILQ_INIT(head) do {                                          \
        (head)->stqh_first = NULL;                                      \
        (head)->stqh_last = &(head)->stqh_first;                                \
} while (/*CONSTCOND*/0)

#define STAILQ_INSERT_HEAD(head, elm, field) do {                       \
        if (((elm)->field.stqe_next = (head)->stqh_first) == NULL)      \
                (head)->stqh_last = &(elm)->field.stqe_next;            \
        (head)->stqh_first = (elm);                                     \
} while (/*CONSTCOND*/0)

#define STAILQ_INSERT_TAIL(head, elm, field) do {                       \
        (elm)->field.stqe_next = NULL;                                  \
        *(head)->stqh_last = (elm);                                     \
        (head)->stqh_last = &(elm)->field.stqe_next;                    \
} while (/*CONSTCOND*/0)

#define STAILQ_INSERT_AFTER(head, listelm, elm, field) do {             \
        if (((elm)->field.stqe_next = (listelm)->field.stqe_next) == NULL)\
                (head)->stqh_last = &(elm)->field.stqe_next;            \
        (listelm)->field.stqe_next = (elm);                             \
} while (/*CONSTCOND*/0)

#define STAILQ_REMOVE_HEAD(head, field) do {                            \
        if (((head)->stqh_first = (head)->stqh_first->field.stqe_next) == NULL) \
                (head)->stqh_last = &(head)->stqh_first;                        \
} while (/*CONSTCOND*/0)

#define STAILQ_REMOVE(head, elm, type, field) do {                      \
        if ((head)->stqh_first == (elm)) {                              \
                STAILQ_REMOVE_HEAD((head), field);                      \
        } else {                                                        \
                struct type *curelm = (head)->stqh_first;               \
                while (curelm->field.stqe_next != (elm))                        \
                        curelm = curelm->field.stqe_next;               \
                if ((curelm->field.stqe_next =                          \
                        curelm->field.stqe_next->field.stqe_next) == NULL) \
                            (head)->stqh_last = &(curelm)->field.stqe_next; \
        }                                                               \
} while (/*CONSTCOND*/0)

#define STAILQ_FOREACH(var, head, field)                                \
        for ((var) = ((head)->stqh_first);                              \
                (var);                                                  \
                (var) = ((var)->field.stqe_next))

#define STAILQ_EMPTY(head)      ((head)->stqh_first == NULL)

#define STAILQ_FIRST(head)      ((head)->stqh_first)

#define STAILQ_NEXT(elm, field) ((elm)->field.stqe_next)

/*
 * Simple queue access methods.
 */
#define SIMPLEQ_EMPTY(head)             ((head)->sqh_first == NULL)
#define SIMPLEQ_FIRST(head)             ((head)->sqh_first)
#define SIMPLEQ_NEXT(elm, field)        ((elm)->field.sqe_next)

/*
 * Simple queue definitions.
 */
#define SIMPLEQ_HEAD(name, type)                                        \
struct name {                                                           \
        struct type *sqh_first; /* first element */                     \
        struct type **sqh_last; /* addr of last next element */         \
}

#define SIMPLEQ_HEAD_INITIALIZER(head)                                  \
        { NULL, &(head).sqh_first }

#define SIMPLEQ_ENTRY(type)                                             \
struct {                                                                \
        struct type *sqe_next;  /* next element */                      \
}

/*
 * Simple queue functions.
 */
#define SIMPLEQ_INIT(head) do {                                         \
        (head)->sqh_first = NULL;                                       \
        (head)->sqh_last = &(head)->sqh_first;                          \
} while (/*CONSTCOND*/0)

#define SIMPLEQ_INSERT_HEAD(head, elm, field) do {                      \
        if (((elm)->field.sqe_next = (head)->sqh_first) == NULL)        \
                (head)->sqh_last = &(elm)->field.sqe_next;              \
        (head)->sqh_first = (elm);                                      \
} while (/*CONSTCOND*/0)

#define SIMPLEQ_INSERT_TAIL(head, elm, field) do {                      \
        (elm)->field.sqe_next = NULL;                                   \
        *(head)->sqh_last = (elm);                                      \
        (head)->sqh_last = &(elm)->field.sqe_next;                      \
} while (/*CONSTCOND*/0)

#define SIMPLEQ_INSERT_AFTER(head, listelm, elm, field) do {            \
        if (((elm)->field.sqe_next = (listelm)->field.sqe_next) == NULL)\
                (head)->sqh_last = &(elm)->field.sqe_next;              \
        (listelm)->field.sqe_next = (elm);                              \
} while (/*CONSTCOND*/0)

#define SIMPLEQ_REMOVE_HEAD(head, field) do {                           \
        if (((head)->sqh_first = (head)->sqh_first->field.sqe_next) == NULL) \
                (head)->sqh_last = &(head)->sqh_first;                  \
} while (/*CONSTCOND*/0)

#define SIMPLEQ_REMOVE(head, elm, type, field) do {                     \
        if ((head)->sqh_first == (elm)) {                               \
                SIMPLEQ_REMOVE_HEAD((head), field);                     \
        } else {                                                        \
                struct type *curelm = (head)->sqh_first;                \
                while (curelm->field.sqe_next != (elm))                 \
                        curelm = curelm->field.sqe_next;                \
                if ((curelm->field.sqe_next =                           \
                        curelm->field.sqe_next->field.sqe_next) == NULL) \
                            (head)->sqh_last = &(curelm)->field.sqe_next; \
        }                                                               \
} while (/*CONSTCOND*/0)

#define SIMPLEQ_FOREACH(var, head, field)                               \
        for ((var) = ((head)->sqh_first);                               \
                (var);                                                  \
                (var) = ((var)->field.sqe_next))

/*
 * Simple queue access methods.
 */
#define SIMPLEQ_EMPTY(head)             ((head)->sqh_first == NULL)
#define SIMPLEQ_FIRST(head)             ((head)->sqh_first)
#define SIMPLEQ_NEXT(elm, field)        ((elm)->field.sqe_next)

/*
 * Tail queue definitions.
 */
#define TAILQ_HEAD(name, type)                                          \
struct name {                                                           \
        struct type *tqh_first; /* first element */                     \
        struct type **tqh_last; /* addr of last next element */         \
}

#define TAILQ_HEAD_INITIALIZER(head)                                    \
        { NULL, &(head).tqh_first }

#define TAILQ_ENTRY(type)                                               \
struct {                                                                \
        struct type *tqe_next;  /* next element */                      \
        struct type **tqe_prev; /* address of previous next element */  \
}

/*
 * Tail queue functions.
 */
#if defined(_KERNEL) && defined(QUEUEDEBUG)
#define QUEUEDEBUG_TAILQ_INSERT_HEAD(head, elm, field)                  \
        if ((head)->tqh_first &&                                        \
            (head)->tqh_first->field.tqe_prev != &(head)->tqh_first)    \
                panic("TAILQ_INSERT_HEAD %p %s:%d", (head), __FILE__, __LINE__);
#define QUEUEDEBUG_TAILQ_INSERT_TAIL(head, elm, field)                  \
        if (*(head)->tqh_last != NULL)                                  \
                panic("TAILQ_INSERT_TAIL %p %s:%d", (head), __FILE__, __LINE__);
#define QUEUEDEBUG_TAILQ_OP(elm, field)                                 \
        if ((elm)->field.tqe_next &&                                    \
            (elm)->field.tqe_next->field.tqe_prev !=                    \
            &(elm)->field.tqe_next)                                     \
                panic("TAILQ_* forw %p %s:%d", (elm), __FILE__, __LINE__);\
        if (*(elm)->field.tqe_prev != (elm))                            \
                panic("TAILQ_* back %p %s:%d", (elm), __FILE__, __LINE__);
#define QUEUEDEBUG_TAILQ_PREREMOVE(head, elm, field)                    \
        if ((elm)->field.tqe_next == NULL &&                            \
            (head)->tqh_last != &(elm)->field.tqe_next)                 \
                panic("TAILQ_PREREMOVE head %p elm %p %s:%d",           \
                      (head), (elm), __FILE__, __LINE__);
#define QUEUEDEBUG_TAILQ_POSTREMOVE(elm, field)                         \
        (elm)->field.tqe_next = (void *)1L;                             \
        (elm)->field.tqe_prev = (void *)1L;
#else
#define QUEUEDEBUG_TAILQ_INSERT_HEAD(head, elm, field)
#define QUEUEDEBUG_TAILQ_INSERT_TAIL(head, elm, field)
#define QUEUEDEBUG_TAILQ_OP(elm, field)
#define QUEUEDEBUG_TAILQ_PREREMOVE(head, elm, field)
#define QUEUEDEBUG_TAILQ_POSTREMOVE(elm, field)
#endif

#define TAILQ_INIT(head) do {                                           \
        (head)->tqh_first = NULL;                                       \
        (head)->tqh_last = &(head)->tqh_first;                          \
} while (/*CONSTCOND*/0)

#define TAILQ_INSERT_HEAD(head, elm, field) do {                        \
        QUEUEDEBUG_TAILQ_INSERT_HEAD((head), (elm), field)              \
        if (((elm)->field.tqe_next = (head)->tqh_first) != NULL)        \
                (head)->tqh_first->field.tqe_prev =                     \
                    &(elm)->field.tqe_next;                             \
        else                                                            \
                (head)->tqh_last = &(elm)->field.tqe_next;              \
        (head)->tqh_first = (elm);                                      \
        (elm)->field.tqe_prev = &(head)->tqh_first;                     \
} while (/*CONSTCOND*/0)

#define TAILQ_INSERT_TAIL(head, elm, field) do {                        \
        QUEUEDEBUG_TAILQ_INSERT_TAIL((head), (elm), field)              \
        (elm)->field.tqe_next = NULL;                                   \
        (elm)->field.tqe_prev = (head)->tqh_last;                       \
        *(head)->tqh_last = (elm);                                      \
        (head)->tqh_last = &(elm)->field.tqe_next;                      \
} while (/*CONSTCOND*/0)

#define TAILQ_INSERT_AFTER(head, listelm, elm, field) do {              \
        QUEUEDEBUG_TAILQ_OP((listelm), field)                           \
        if (((elm)->field.tqe_next = (listelm)->field.tqe_next) != NULL)\
                (elm)->field.tqe_next->field.tqe_prev =                 \
                    &(elm)->field.tqe_next;                             \
        else                                                            \
                (head)->tqh_last = &(elm)->field.tqe_next;              \
        (listelm)->field.tqe_next = (elm);                              \
        (elm)->field.tqe_prev = &(listelm)->field.tqe_next;             \
} while (/*CONSTCOND*/0)

#define TAILQ_INSERT_BEFORE(listelm, elm, field) do {                   \
        QUEUEDEBUG_TAILQ_OP((listelm), field)                           \
        (elm)->field.tqe_prev = (listelm)->field.tqe_prev;              \
        (elm)->field.tqe_next = (listelm);                              \
        *(listelm)->field.tqe_prev = (elm);                             \
        (listelm)->field.tqe_prev = &(elm)->field.tqe_next;             \
} while (/*CONSTCOND*/0)

#define TAILQ_REMOVE(head, elm, field) do {                             \
        QUEUEDEBUG_TAILQ_PREREMOVE((head), (elm), field)                \
        QUEUEDEBUG_TAILQ_OP((elm), field)                               \
        if (((elm)->field.tqe_next) != NULL)                            \
                (elm)->field.tqe_next->field.tqe_prev =                 \
                    (elm)->field.tqe_prev;                              \
        else                                                            \
                (head)->tqh_last = (elm)->field.tqe_prev;               \
        *(elm)->field.tqe_prev = (elm)->field.tqe_next;                 \
        QUEUEDEBUG_TAILQ_POSTREMOVE((elm), field);                      \
} while (/*CONSTCOND*/0)

/*
 * Tail queue access methods.
 */
#define TAILQ_EMPTY(head)               ((head)->tqh_first == NULL)
#define TAILQ_FIRST(head)               ((head)->tqh_first)
#define TAILQ_NEXT(elm, field)          ((elm)->field.tqe_next)

#define TAILQ_LAST(head, headname) \
        (*(((struct headname *)((head)->tqh_last))->tqh_last))
#define TAILQ_PREV(elm, headname, field) \
        (*(((struct headname *)((elm)->field.tqe_prev))->tqh_last))

#define TAILQ_FOREACH(var, head, field)                                 \
        for ((var) = ((head)->tqh_first);                               \
                (var);                                                  \
                (var) = ((var)->field.tqe_next))

#define TAILQ_FOREACH_REVERSE(var, head, headname, field)               \
        for ((var) = (*(((struct headname *)((head)->tqh_last))->tqh_last));    \
                (var);                                                  \
                (var) = (*(((struct headname *)((var)->field.tqe_prev))->tqh_last)))

/*
 * Circular queue definitions.
 */
#define CIRCLEQ_HEAD(name, type)                                        \
struct name {                                                           \
        struct type *cqh_first;         /* first element */             \
        struct type *cqh_last;          /* last element */              \
}

#define CIRCLEQ_HEAD_INITIALIZER(head)                                  \
        { (void *)&head, (void *)&head }

#define CIRCLEQ_ENTRY(type)                                             \
struct {                                                                \
        struct type *cqe_next;          /* next element */              \
        struct type *cqe_prev;          /* previous element */          \
}

/*
 * Circular queue functions.
 */
#define CIRCLEQ_INIT(head) do {                                         \
        (head)->cqh_first = (void *)(head);                             \
        (head)->cqh_last = (void *)(head);                              \
} while (/*CONSTCOND*/0)

#define CIRCLEQ_INSERT_AFTER(head, listelm, elm, field) do {            \
        (elm)->field.cqe_next = (listelm)->field.cqe_next;              \
        (elm)->field.cqe_prev = (listelm);                              \
        if ((listelm)->field.cqe_next == (void *)(head))                \
                (head)->cqh_last = (elm);                               \
        else                                                            \
                (listelm)->field.cqe_next->field.cqe_prev = (elm);      \
        (listelm)->field.cqe_next = (elm);                              \
} while (/*CONSTCOND*/0)

#define CIRCLEQ_INSERT_BEFORE(head, listelm, elm, field) do {           \
        (elm)->field.cqe_next = (listelm);                              \
        (elm)->field.cqe_prev = (listelm)->field.cqe_prev;              \
        if ((listelm)->field.cqe_prev == (void *)(head))                \
                (head)->cqh_first = (elm);                              \
        else                                                            \
                (listelm)->field.cqe_prev->field.cqe_next = (elm);      \
        (listelm)->field.cqe_prev = (elm);                              \
} while (/*CONSTCOND*/0)

#define CIRCLEQ_INSERT_HEAD(head, elm, field) do {                      \
        (elm)->field.cqe_next = (head)->cqh_first;                      \
        (elm)->field.cqe_prev = (void *)(head);                         \
        if ((head)->cqh_last == (void *)(head))                         \
                (head)->cqh_last = (elm);                               \
        else                                                            \
                (head)->cqh_first->field.cqe_prev = (elm);              \
        (head)->cqh_first = (elm);                                      \
} while (/*CONSTCOND*/0)

#define CIRCLEQ_INSERT_TAIL(head, elm, field) do {                      \
        (elm)->field.cqe_next = (void *)(head);                         \
        (elm)->field.cqe_prev = (head)->cqh_last;                       \
        if ((head)->cqh_first == (void *)(head))                        \
                (head)->cqh_first = (elm);                              \
        else                                                            \
                (head)->cqh_last->field.cqe_next = (elm);               \
        (head)->cqh_last = (elm);                                       \
} while (/*CONSTCOND*/0)

#define CIRCLEQ_REMOVE(head, elm, field) do {                           \
        if ((elm)->field.cqe_next == (void *)(head))                    \
                (head)->cqh_last = (elm)->field.cqe_prev;               \
        else                                                            \
                (elm)->field.cqe_next->field.cqe_prev =                 \
                    (elm)->field.cqe_prev;                              \
        if ((elm)->field.cqe_prev == (void *)(head))                    \
                (head)->cqh_first = (elm)->field.cqe_next;              \
        else                                                            \
                (elm)->field.cqe_prev->field.cqe_next =                 \
                    (elm)->field.cqe_next;                              \
} while (/*CONSTCOND*/0)

#define CIRCLEQ_FOREACH(var, head, field)                               \
        for ((var) = ((head)->cqh_first);                               \
                (var) != (void *)(head);                                \
                (var) = ((var)->field.cqe_next))

#define CIRCLEQ_FOREACH_REVERSE(var, head, field)                       \
        for ((var) = ((head)->cqh_last);                                \
                (var) != (void *)(head);                                \
                (var) = ((var)->field.cqe_prev))

/*
 * Circular queue access methods.
 */
#define CIRCLEQ_EMPTY(head)             ((head)->cqh_first == (void *)(head))
#define CIRCLEQ_FIRST(head)             ((head)->cqh_first)
#define CIRCLEQ_LAST(head)              ((head)->cqh_last)
#define CIRCLEQ_NEXT(elm, field)        ((elm)->field.cqe_next)
#define CIRCLEQ_PREV(elm, field)        ((elm)->field.cqe_prev)
#endif  /* !_SYS_QUEUE_H_ */

main.c:

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include "queue.h"

struct dpd_event_entry {
    uint32_t sa_id;
    TAILQ_ENTRY(dpd_event_entry) link;
};

static TAILQ_HEAD(_dpd_event_queue_, dpd_event_entry) dpd_event_queue;

void init(void)
{
    TAILQ_INIT(&dpd_event_queue);
}

int32_t insert(uint32_t id)
{
    struct dpd_event_entry *new = NULL;

    new = (struct dpd_event_entry *)malloc(sizeof(struct dpd_event_entry *));
    if (NULL == new) {
        return -1;
    }

    new->sa_id = id;

    TAILQ_INSERT_TAIL(&dpd_event_queue, new, link);
    return 0;
}

void show(void)
{
    struct dpd_event_entry *curr = NULL;
    printf("\n===show===\n");
    TAILQ_FOREACH(curr, &dpd_event_queue, link) {
       printf("id = %d\n", curr->sa_id);
    }
}

int32_t remove_id(uint32_t id)
{
    struct dpd_event_entry *curr = NULL;

    TAILQ_FOREACH(curr, &dpd_event_queue, link) {
        if (curr->sa_id != id) {
            continue;
        }
        printf("find id = %d\n", curr->sa_id);
        break;
    }

    if (NULL == curr) {
        return -1;
    }
    printf("will remove id = %d\n", curr->sa_id);
    TAILQ_REMOVE(&dpd_event_queue, curr, link);
    return 0;
}

int
main(int argc, char *const argv[])
{
    int i = 0;

    init();

    for (i = 0; i < 10; i++) {
        insert(i+1);
    }
    show();

    i = 3;
    printf("I want to remove id = %d\n", i);
    remove_id(i);
    show();

    for (i = 0; i < 10; i++) {
        remove_id(i+1);
    }
    show();

}

结果：

$ gcc main.c
$ ls
a.out main.c  queue.h 
[hillstone@hillstone TAILQ_test]$ ./a.out

===show===
id = 1
id = 2
id = 3
id = 4
id = 5
id = 6
id = 7
id = 8
id = 9
id = 10
I want to remove id = 3
find id = 3
will remove id = 3

===show===
id = 1
id = 2
id = 4
id = 5
id = 6
id = 7
id = 8
id = 9
id = 10
find id = 1
will remove id = 1
find id = 2
will remove id = 2
find id = 4
will remove id = 4
find id = 5
will remove id = 5
find id = 6
will remove id = 6
find id = 7
will remove id = 7
find id = 8
will remove id = 8
find id = 9
will remove id = 9
find id = 10
will remove id = 10

===show===
daa20
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
libevent源码之TAILQ详解
博客
06-14 2410
首先，让我们看看插入操作的源代码： #define TAILQ_INSERT_TAIL(head, elm, field) do {            \     (elm)->field.tqe_next = NULL;                    \     (elm)->field.tqe_prev = (head)->tqh_last;            \
通用数据结构
07-20 719
几乎对于所有的程序来说不能缺少数据结构这个角色，不管是常用的单链表、双向链表还是队列，还是也不时碰到的堆、哈希表等等。如果这些这些东西在项目是经常使用到的话，那么如果只开发一次，再所有的项目都能使用上的话，是不是可以节省下来很多时间呢？当然，对于一些解析性的语言来说，这些都是包含在自己的语言库里，这帮了我们不少的忙。但是对于C语言来说，要想使用这些就得自己去实现，如果要想开发一套在所有项目中都能通
深入理解FreeBSD中的TAILQ
yrtayj的专栏
02-20 1260
工作的主要内容是tcp/ip，平台是FreeBSD，而且在内核态开发，所以很多情况下会涉及内核的一些数据结构和宏，比如说mbuf和TAILQ等。 TAILQ是FreeBSD/linux内核对双向队列操作的一种抽象，抽象程度不亚于C++，能实现操作队列需要的各种操作：插入元素，删除元素，遍历队列等。这个队列的优点是插入元素很快。 这里先回顾一下队列的特点（来自维基百科 http://zh.wik
C 宏实现队列
独钓寒江雪
05-03 3364
http://trac.openrays.org/projects/pmon/browser/trunk/sys/sys/queue.h?rev=2/*      $OpenBSD: queue.h,v 1.14 1999/09/08 08:20:04 espie Exp $        */2/*      $NetBSD: queue.h,v 1.11 1996/05/16 05:17:14 mycroft Exp $       */3 4/*5 * Copyright (c) 1991, 1993
Linux内嵌链表（sys/queue.h）详解
热门推荐
tissar的博客
02-11 1万+
Linux 内嵌链表（sys/queue.h）详解queue 简介SLISTSTAILQLISTTAILQCIRCLEQ例程 queue 简介 C语言不像C++语言可以使用STL，在编程中需要用到链表时，通常需要程序员重新设计链表的结构体。不统一的编程规范会增加代码的阅读难度，而且链表的正确性需要验证。 头文件queue.h为C语言中的链表提供了更加标准规范的编程接口。如今的版本多为伯克利加州大...
c语言尾队列tailq使用示例分享
09-04
在示例程序中，我们首先定义了一个结构体`tailq_entry`，它包含一个整数值`value`和一个指向上一个和下一个元素的指针`entries`。然后，我们定义了一个队列头部`my_tailq_head`，用于存储队列中的元素。 在`main`...
queue.h ---- TAILQ_FOREACH_SAFE
09-01
改进了linux tailq队列下在遍历时删除多个元素的问题。可以使用TAILQ_FOREACH_SAFE下面进行节点删除操作。不会出现野指针问题
各种链表队列宏操作的应用例子
06-28
首先，**单链表（Singly-linked List）**是一种线性数据结构，每个元素（节点）包含一个数据部分和一个指向下一个节点的指针。单链表操作的常见宏包括创建新节点、插入节点、删除节点和遍历链表等。例如，`CREATE_...
linux上queue.h 队列的实现
07-09
linux上queue.h，可用于一直实现双向链表.亲测非常好用 linux上queue.h，可用于一直实现双向链表.亲测非常好用 linux上queue.h，可用于一直实现双向链表.亲测非常好用
链表之SLIST
车子（chezi）
02-13 2932
文章目录背景SLIST 简介接口和实现举例代码分析SLIST_ENTRY 和 SLIST_HEADSLIST_INITSLIST_INSERT_HEADSLIST_INSERT_AFTERSLIST_REMOVESLIST_FIRST 和 SLIST_REMOVE_HEADSLIST_FOREACHSLIST_EMPTY 和 SLIST_INIT附录 queue.h参考资料 背景 对于 C 语言，在编程中需要用到链表时，通常需要程序员重新设计链表的结构体。这样做不仅麻烦，且需要验证代码的正确性，对于每个阅读
各种链表队列的宏操作及应用
把自己当做自己，把别人当做别人；把自己当做别人，把别人当做自己
06-28 542
链表队列的宏操作参考自libevent，这种链表的宏操作非常容易移植，现在我将它记录下来。所有例子的代码请前往各种链表队列宏操作的应用例子免积分下载。 Singly-linked List /* * Singly-linked List definitions. */ #define SLIST_HEAD(name, type) \ struct name {
设计之美-链表与队列
双林子木
08-03 2181
数据结构概述随着计算机科学的发展，人们在计算机的各个领域创造了许多前所唯有的东西，在软件领域，在追求算法效率的同时与其紧密相连的就是数据结构。好的数据结构不仅可以有效的管理计算机中的所有数据，同时还能为为算法的设计上提供了许多意想不到的好处，因此许多高效的算法都是依赖其特定的数据结构对所操纵的数据进行组织的。即使现如今计算机硬件仍然遵循摩尔定律在高速发展着，但人类的需求总是大于硬件发展所能提供的性能
Libevent: 在C语言中实现泛型数据结构
u012342808的博客
03-04 783
窥探C语言中的实现泛型数据结构的技巧
jetson tx学习总结
lwq123free的博客
05-29 1091
最近搞了下nvidia的jetson tx1 and tx2 ，实验室马上就到最新的xavier系列了（有点小激动），后面将详细写下xavier的学习过程，tx1和 tx2 就扔了，把之前用的时候一些所学所想记下（只针对用tx1和tx2来学习ROS的）。 安装： 用jetpack安装，不同的版本安装的ros版本也不一样，但要注意，tx1还是安装14.04更好，因为我之前tx1装16.04,然后...
libevent中的基本数据结构
多看多听多总结
05-05 1313
libevent中文件queue.c文件包含5种数据结构：单链表，双向链表，队列，尾队列，环形队列。在处理I/O和signal中的事件时，用的就是尾队列，下面就介绍这几种数据结构 1、单链表 链表头用宏SLIT_HEAD来定义 #define SLIST_HEAD(name, type) \ struct name { \ struct
libevent源码深度剖析之队列
努力才会有幸福
05-04 311
一、单链表 /* * Singly-linked List definitions. */ #define SLIST_HEAD(name, type) \ struct name { \ struct type *slh_first; /* first element */ \ } #define SLIST_HEAD_INITIALIZER(head) ...
8天玩转并行开发——第三天 plinq的使用
weixin_34281477的博客
04-04 107
       相信在.net平台下，我们都玩过linq，是的，linq让我们的程序简洁优美，简直玩的是爱不释手，但是传统的linq只是串行代码，在并行的 年代如果linq不支持并行计算那该是多么遗憾的事情啊。    当然linq有很多种方式，比如linq to sql ,xml，object 等等，如果要将linq做成并行还是很简单的，这里我就举一个比较实际一点的例子， 我们知道为了更快的...
C语言宏定义实现数据结构（一）
qq_38329839的博客
10-10 1507
C语言宏定义实现数据结构（一） 最近在学习C语言，看到C的预处理命令define博大精深，研究了下C宏定义的高级用法，之前链表都是普通的结构体实现感觉不太优雅，现在学习了下宏定义就用它来实现了，同时也给自己做一些知识的梳理，其实也就是参考了libevent的数据结构啦(哈哈)。 //单链表的头部 #define SLIST_HEAD(name, type) \ struct name { ...
Queue学习之Singly-Linked List
LYH66的专栏
05-27 2416
早就听说了libevent这个开源网络库的大名，刚好最近时间比较闲，所以就拜读一下。计划是从0.1版本（最早版）开始看起，因为我想看一下libevent成长历史和网络通信方面的相关技术发展。在libevent0.1版本中，核心就是event这个结构体了。而这个结构体中又用了sys/queue.h中的TAIL QUEUES。因此打算先学习一下sys/queue.h中提到的几个queue。本文将会讲解一
TAILQ_INIT
最新发布
04-25
TAILQ_INIT是一个宏，用于初始化一个双向链表的头结点。它是在FreeBSD操作系统中定义的，用于实现双向链表的数据结构。 在使用TAILQ_INIT宏时，需要先定义一个结构体作为链表的节点，该结构体中需要包含两个指针，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值