Linux内核队列queue.h

文章目录

  • 一、简介
  • 二、SLIST单向无尾链表
    • 2.1 介绍
    • 2.2 操作
    • 2.3 例子
  • 三、STAILQ单向有尾链表
  • 四、LIST双向无尾链表
  • 五、TAILQ双向有尾链表
  • 六、CIRCLEQ循环链表
  • 七、queue源码
  • 参考

一、简介

queue.h是一个非常经典的文件，定义了一系列宏的操作，它定义了一系列的宏操作，实现了链表，尾队列和循环链表。
queue.h定义了5个基本的数据类型：

  • 单向无尾链表
  • 单向有尾链表
  • 双向无尾链表
  • 双向有尾链表
  • 循环链表

queue相关链表/队列的使用流程为：

  1. 定义自己的结构体
  2. 在结构体中使用XXXX_ENTRY定义链表/队列成员变量
  3. 使用XXXX_HEAD定义一个链表/队列头
  4. 使用XXXX_INIT初始化链表/队列头（也可在定义时初始化）
  5. 使用相关的INSERT、REMOVE、FOREACH、REPLACE方法操作队列

几种类型支持的操作：
在这里插入图片描述

二、SLIST单向无尾链表

2.1 介绍

SLIST是Singly-linked List的缩写，意为单向无尾链表。
在这里插入图片描述
SLIST适合数据量非常大并且几乎不需要删除数据的场合，或者当作堆栈使用。
SLIST相关的源码：

/** 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_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_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)#define SLIST_FOREACH(var, head, field)                                     \for ((var) = SLIST_FIRST((head));                                       \(var);                                                              \(var) = SLIST_NEXT((var), field) )#define SLIST_FOREACH_PREVPTR(var, varp, head, field)                       \for ((varp) = &SLIST_FIRST((head));                                     \((var) = *(varp)) != NULL;                                          \(varp) = &SLIST_NEXT((var), field) )/** Singly-linked List access methods.*/
#define SLIST_EMPTY(head)       ((head)->slh_first == NULL)
#define SLIST_FIRST(head)       ((head)->slh_first)
#define SLIST_NEXT(elm, field)  ((elm)->field.sle_next)

2.2 操作

与单向链表相关的宏、方法和函数有：

// definitions
SLIST_HEAD(name, type)
SLIST_HEAD_INITIALIZER(head)
SLIST_ENTRY(type)
// access methods
SLIST_FIRST(head)
SLIST_END(head)
SLIST_EMPTY(head)
SLIST_NEXT(elm, field)
LIST_FOREACH(var, head, field)
SLIST_FOREACH_PREVPTR(var, varp, head, field)
// functions
SLIST_INIT(head)
SLIST_INSERT_AFTER(slistelm, elm, field)
SLIST_INSERT_HEAD(head, elm, field)
SLIST_REMOVE_NEXT(head, elm, field)
SLIST_REMOVE_HEAD(head, field)
SLIST_REMOVE(head, elm, type, field)

宏定义说明

  • SLIST_HEAD用于定义一个单向链表数据结构体的头变量，该结构体只有一个指针成员slh_first，指向第一个type类型的数据结构；name可以不用（填写）；
  • SLIST_HEAD_INITIALIZER用于在定义时初始化SLIST_HEAD定义的数据结构体的头变量；head可以不用填写;
  • SLIST_ENTRY则用于定义一个（用户）结构体的成员变量，该成员变量只包含一个指向type类型的指针sle_next；

与单向链表相关的访问方法有6个

  • SLIST_FIRST用于获取单向链表的第一个元素；
  • SLIST_END定义了尾部的判断标准；
  • SLIST_EMPTY用于判断单向链表是否为空：空则返回true，否则返回false；
  • SLIST_NEXT用于获取elm元素的下一个元素，field是前面用SLIST_ENTRY定义的成员变量名；
  • SLIST_FOREACH用于遍历单向链表，var是临时变量，head是链表头指针（SLIST_HEAD定义的变量），field是SLIST_ENTRY定义的成员变量名；
  • SLIST_FOREACH_PREVPTR与SLIST_FOREACH类似，用于遍历单向链表，不过提供更多的一个临时指针变量varp，指向var指向元素的地址；

与单向链表相关的函数有6个

  • SLIST_INIT用于初始化SLIST_HEAD定义的头指针变量；当然也可以在使用SLIST_HEAD定义头指针变量时同时使用SLIST_HEAD_INITIALIZER进行初始化；
  • SLIST_INSERT_AFTER用于将元素elm插入到当前链表元素slistelm的后面；
  • SLIST_INSERT_HEAD用于将元素elm插入到当前链表head的头部；head是SLIST_HEAD定义的链表头指针；
  • SLIST_REMOVE_NEXT用于将elm后面的元素删除，head未使用；注意删除时判断elm后面是否还有元素，否则会崩溃;
  • SLIST_REMOVE_HEAD用于删除第一个元素；注意删除时判断head是否为空，否则会崩溃;
  • SLIST_REMOVE用于从head链表中删除elm元素；注意首先判断elm元素是否在head链表中，否则会崩溃；

2.3 例子

#include <stdio.h>
#include <stdlib.h>
#include "queue.h"struct SLIST_ITEM {int value;SLIST_ENTRY(SLIST_ITEM) entry;
};
int main(void) {int i;SLIST_HEAD(,SLIST_ITEM) slist_head;SLIST_INIT(&slist_head);if (SLIST_EMPTY(&slist_head))printf("single list is empty\n");struct SLIST_ITEM *item;struct SLIST_ITEM *item_temp;for( i = 0; i < 10; i += 1){item = (struct SLIST_ITEM *)malloc(sizeof(struct SLIST_ITEM));item->value = i;item->entry.sle_next = NULL;SLIST_INSERT_HEAD(&slist_head, item, entry);}printf("after insert 10 item to single list:\n");SLIST_FOREACH(item, &slist_head, entry)printf("item value = %d\n", item->value);while( SLIST_EMPTY(&slist_head) == 0 ){item_temp = (&slist_head)->slh_first;SLIST_REMOVE(&slist_head,(&slist_head)->slh_first,SLIST_ITEM,entry);free(item_temp);}printf("here");if ( SLIST_EMPTY(&slist_head) )printf("single list is empty\n");        return 0;
}

在这里插入图片描述

  • SLIST_INSERT_HEAD(&slist_head, item, entry)
    从头部插入元素，第一个参数为头节点，第一个参数为要插入的元素，第三个参数为自定义结构体中，自定义的SLIST_ENTRY(SLIST_ITEM)结构体变量名称。
  • SLIST_REMOVE(&slist_head,(&slist_head)->slh_first,SLIST_ITEM,entry)
    删除对应元素( 内部仅是指针指向的改变，没有真正释放空间 )

三、STAILQ单向有尾链表

STAILQ 是 Singly-linked Tail queue 的缩写，意为单向有尾链表。有尾链表可作队列使用。
在这里插入图片描述
STAILQ相关的源码

/** 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_CONCAT(head1, head2) do {                                    \if (!STAILQ_EMPTY((head2))) {                                           \*(head1)->stqh_last = (head2)->stqh_first;                          \(head1)->stqh_last = (head2)->stqh_last;                            \STAILQ_INIT((head2));                                               \}                                                                       \
} while (/*CONSTCOND*/0)/** Singly-linked Tail queue access methods.*/
#define STAILQ_EMPTY(head)          ((head)->stqh_first == NULL)
#define STAILQ_FIRST(head)          ((head)->stqh_first)
#define STAILQ_NEXT(elm, field)     ((elm)->field.stqe_next)

四、LIST双向无尾链表

双向链表有前向的指针，因此可以执行一些前向操作，而且无需遍历链表便可以删除一些节点。
在这里插入图片描述
LIST相关的源码

/** 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.*/
#define LIST_INIT(head) do {                                                \(head)->lh_first = NULL;                                                \
} while (/*CONSTCOND*/0)#define LIST_INSERT_AFTER(listelm, elm, field) do {                         \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 {                        \(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 {                             \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 {                                        \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;                           \
} 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)

五、TAILQ双向有尾链表

TAILQ 是 Tail queue 的缩写，意为双向有尾链表。
有尾链表可作队列使用。
双向有尾链表兼具了双向链表和有尾链表的特点。
在这里插入图片描述
TAILQ相关的源码

/** 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.*/
#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 {                            \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 {                            \(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 {                  \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 {                       \(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 {                                 \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;                         \
} while (/*CONSTCOND*/0)#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)))#define TAILQ_CONCAT(head1, head2, field) do {                              \if (!TAILQ_EMPTY(head2)) {                                              \*(head1)->tqh_last = (head2)->tqh_first;                            \(head2)->tqh_first->field.tqe_prev = (head1)->tqh_last;             \(head1)->tqh_last = (head2)->tqh_last;                              \TAILQ_INIT((head2));                                                \}                                                                       \
} 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))

六、CIRCLEQ循环链表

CIRCLEQ 是 Circular queue 的缩写，意为循环链表。
在这里插入图片描述
CIRCLEQ相关的源码

/** 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) != (const void *)(head);                                      \(var) = ((var)->field.cqe_next))#define CIRCLEQ_FOREACH_REVERSE(var, head, field)                           \for ((var) = ((head)->cqh_last);                                        \(var) != (const 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)#define CIRCLEQ_LOOP_NEXT(head, elm, field)                                 \(((elm)->field.cqe_next == (void *)(head))                              \? ((head)->cqh_first)                                               \: (elm->field.cqe_next))#define CIRCLEQ_LOOP_PREV(head, elm, field)                                 \(((elm)->field.cqe_prev == (void *)(head))                              \? ((head)->cqh_last)                                                \: (elm->field.cqe_prev))

七、queue源码

在Linux系统中的路径为：/usr/include/sys/queue.h
也可以通过如下网址查看：https://codebrowser.dev/glibc/glibc/misc/sys/queue.h.html
queue.h

/** Copyright (c) 1991, 1993*        The Regents of the University of California.  All rights reserved.** Redistribution and use in source and binary forms, with or without* modification, are permitted provided that the following conditions* are met:* 1. Redistributions of source code must retain the above copyright*    notice, this list of conditions and the following disclaimer.* 2. Redistributions in binary form must reproduce the above copyright*    notice, this list of conditions and the following disclaimer in the*    documentation and/or other materials provided with the distribution.* 3. Neither the name of the University nor the names of its contributors*    may be used to endorse or promote products derived from this software*    without specific prior written permission.** THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE* ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF* SUCH DAMAGE.**        @(#)queue.h        8.5 (Berkeley) 8/20/94*/
#ifndef        _QUEUE_H_
#define        _QUEUE_H_
/** This file defines five types of data structures: singly-linked lists,* lists, simple queues, tail queues, and circular queues.** A singly-linked list is headed by a single forward pointer. The* elements are singly linked for minimum space and pointer manipulation* overhead at the expense of O(n) removal for arbitrary elements. New* elements can be added to the list after an existing element or at the* head of the list.  Elements being removed from the head of the list* should use the explicit macro for this purpose for optimum* efficiency. A singly-linked list may only be traversed in the forward* direction.  Singly-linked lists are ideal for applications with large* datasets and few or no removals or for implementing a LIFO queue.** A list is headed by a single forward pointer (or an array of forward* pointers for a hash table header). The elements are doubly linked* so that an arbitrary element can be removed without a need to* traverse the list. New elements can be added to the list before* or after an existing element or at the head of the list. A list* may only be traversed in the forward direction.** A simple queue is headed by a pair of pointers, one the head of the* list and the other to the tail of the list. The elements are singly* linked to save space, so elements can only be removed from the* head of the list. New elements can be added to the list after* an existing element, at the head of the list, or at the end of the* list. A simple queue may only be traversed in the forward direction.** A tail queue is headed by a pair of pointers, one to the head of the* list and the other to the tail of the list. The elements are doubly* linked so that an arbitrary element can be removed without a need to* traverse the list. New elements can be added to the list before or* after an existing element, at the head of the list, or at the end of* the list. A tail queue may be traversed in either direction.** A circle queue is headed by a pair of pointers, one to the head of the* list and the other to the tail of the list. The elements are doubly* linked so that an arbitrary element can be removed without a need to* traverse the list. New elements can be added to the list before or after* an existing element, at the head of the list, or at the end of the list.* A circle queue may be traversed in either direction, but has a more* complex end of list detection.** For details on the use of these macros, see the queue(3) manual page.*/
/** 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.*/
#define        LIST_INIT(head) do {                                                \(head)->lh_first = NULL;                                        \
} while (/*CONSTCOND*/0)
#define        LIST_INSERT_AFTER(listelm, elm, field) do {                        \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 {                        \(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 {                                \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 {                                        \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;                        \
} 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_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_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)
#define        SLIST_FOREACH(var, head, field)                                        \for((var) = (head)->slh_first; (var); (var) = (var)->field.sle_next)
/** Singly-linked List access methods.*/
#define        SLIST_EMPTY(head)        ((head)->slh_first == NULL)
#define        SLIST_FIRST(head)        ((head)->slh_first)
#define        SLIST_NEXT(elm, field)        ((elm)->field.sle_next)
/** 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_CONCAT(head1, head2) do {                                \if (!STAILQ_EMPTY((head2))) {                                        \*(head1)->stqh_last = (head2)->stqh_first;                \(head1)->stqh_last = (head2)->stqh_last;                \STAILQ_INIT((head2));                                        \}                                                                \
} while (/*CONSTCOND*/0)
/** Singly-linked Tail queue access methods.*/
#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 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, qual)                                        \
struct name {                                                                \qual type *tqh_first;                /* first element */                \qual type *qual *tqh_last;        /* addr of last next element */        \
}
#define TAILQ_HEAD(name, type)        _TAILQ_HEAD(name, struct type,)
#define        TAILQ_HEAD_INITIALIZER(head)                                        \{ NULL, &(head).tqh_first }
#define        _TAILQ_ENTRY(type, qual)                                        \
struct {                                                                \qual type *tqe_next;                /* next element */                \qual type *qual *tqe_prev;        /* address of previous next element */\
}
#define TAILQ_ENTRY(type)        _TAILQ_ENTRY(struct type,)
/** Tail queue functions.*/
#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 {                        \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 {                        \(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 {                \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 {                        \(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 {                                \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;                        \
} while (/*CONSTCOND*/0)
#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)))
#define        TAILQ_CONCAT(head1, head2, field) do {                                \if (!TAILQ_EMPTY(head2)) {                                        \*(head1)->tqh_last = (head2)->tqh_first;                \(head2)->tqh_first->field.tqe_prev = (head1)->tqh_last;        \(head1)->tqh_last = (head2)->tqh_last;                        \TAILQ_INIT((head2));                                        \}                                                                \
} 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))
/** 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) != (const void *)(head);                                \(var) = ((var)->field.cqe_next))
#define        CIRCLEQ_FOREACH_REVERSE(var, head, field)                        \for ((var) = ((head)->cqh_last);                                \(var) != (const 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)
#define CIRCLEQ_LOOP_NEXT(head, elm, field)                                \(((elm)->field.cqe_next == (void *)(head))                        \? ((head)->cqh_first)                                        \: (elm->field.cqe_next))
#define CIRCLEQ_LOOP_PREV(head, elm, field)                                \(((elm)->field.cqe_prev == (void *)(head))                        \? ((head)->cqh_last)                                        \: (elm->field.cqe_prev))
#endif        /* sys/queue.h */

参考

  1. https://www.codeleading.com/article/52881355491/
  2. https://blog.csdn.net/tissar/article/details/86978743

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/715161.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

笔记72：关于IMU（惯性测量单元）传感器的作用【不涉及公式推导】

笔记72：关于IMU（惯性测量单元）传感器的作用【不涉及公式推导】

一、IMU传感器是什么&#xff1a; 惯性测量单元IMU&#xff08;Inertial Measurement Unit&#xff09;是一种使用【加速度计】和【陀螺仪】来测量【物体三轴姿态角&#xff08;空间姿态&#xff09;】的装置&#xff1b;IMU在坐标系的每个坐标轴上&#xff0c;均安装有1个陀螺…
阅读更多...
90-子集2(回溯算法)

90-子集2(回溯算法)

题目 给你一个整数数组 nums &#xff0c;其中可能包含重复元素&#xff0c;请你返回该数组所有可能的子集&#xff08;幂集&#xff09;。 解集 不能 包含重复的子集。返回的解集中&#xff0c;子集可以按 任意顺序 排列。 示例 1&#xff1a; 输入&#xff1a;nums [1,2,2] …
阅读更多...
深入理解CSS常见选择器

深入理解CSS常见选择器

标题&#xff1a;深入理解CSS常见选择器 在CSS中&#xff0c;选择器是一种强大的工具&#xff0c;用于定位和样式化HTML文档中的元素。通过选择器的灵活运用&#xff0c;我们能够精准地选择需要操作的元素&#xff0c;从而实现丰富多彩的页面布局和设计。本文将重点介绍常见的…
阅读更多...
Vue2：用node+express部署Vue项目

Vue2：用node+express部署Vue项目

一、编译项目 命令 npm run build执行命令后&#xff0c;我们会在项目文件夹中看到如下生成的文件 二、部署Vue项目 接上一篇&#xff0c;nodeexpress编写轻量级服务 1、在demo中创建static文件夹 2、将dist目录中的文件放入static中 3、修改server.js文件 关键配置&…
阅读更多...
全量知识系统问题及SmartChat给出的答复 之13 解析器+DDD+文法型

全量知识系统问题及SmartChat给出的答复 之13 解析器+DDD+文法型

Q32. DDD的领域概念和知识系统中设计的解析器之间的关系。 那下面&#xff0c;我们回到前面的问题上来。 前面说到了三种语法解析器&#xff0c;分别是 形式语言的&#xff08;机器或计算机语言&#xff09;、人工语言的和自然语言的。再前面&#xff0c;我们聊到了DDD设计思…
阅读更多...
基于java的学生派遣信息管理系统设计开题报告

基于java的学生派遣信息管理系统设计开题报告

欢迎添加微信互相交流学习哦&#xff01; 项目源码&#xff1a;biye2: 毕业设计源码 一、项目名称 Java基于学生派遣信息管理系统设计 二、项目背景 随着科技的发展&#xff0c;互联网在我国的应用越来越广泛&#xff0c;尤其是在教育领域。为了能更好地管理学生派遣信息&am…
阅读更多...
DayDreamInGIS 之 ArcGIS Pro二次开发 图层属性中换行符等特殊字符替换

DayDreamInGIS 之 ArcGIS Pro二次开发 图层属性中换行符等特殊字符替换

具体参考ArcMap中类似的问题&#xff0c;本帖开发一个ArcGISPro版的工具 1.基础库部分 插件开发&#xff0c;经常需要处理图层与界面的交互。基础库把常用的交互部分做了封装&#xff0c;方便之后的重复使用。 &#xff08;1&#xff09;下述类定义了数据存储结构&#xff0…
阅读更多...
DFA还原白盒AES密钥

DFA还原白盒AES密钥

本期内容是关于某app模拟登录的,涉及的知识点比较多,有unidbg补环境及辅助还原算法,ida中的md5以及白盒aes,fart脱壳,frida反调试 本章所有样本及资料均上传到了123云盘 llb资料官方版下载丨最新版下载丨绿色版下载丨APP下载-123云盘 目录 首先抓包 fart脱壳 加密位置定位…
阅读更多...
0048__Unix传奇

0048__Unix传奇

Unix传奇 &#xff08;上篇&#xff09;_unix传奇(上篇)-CSDN博客 Unix传奇 &#xff08;下篇&#xff09;-CSDN博客 Unix现状与未来——CSDN对我的采访_nuix邮件系统行业地位-CSDN博客
阅读更多...
win11安装nodejs

win11安装nodejs

一、下载安装包 链接: https://pan.baidu.com/s/1_df8s1UlgNNaewWrWgI59A?pwdpsjm 提取码: psjm 二、安装步骤 1.双击安装包 2.Next> 3.勾选之后&#xff0c;Next> 4.点击Change&#xff0c;选择你要安装的路径&#xff0c;然后Next> 5.点击Install安装 二、…
阅读更多...
学生云服务器腾讯云_腾讯云学生学生_腾讯云学生云主机

学生云服务器腾讯云_腾讯云学生学生_腾讯云学生云主机

2024年腾讯云学生服务器优惠活动「云校园」&#xff0c;学生服务器优惠价格&#xff1a;轻量应用服务器2核2G学生价30元3个月、58元6个月、112元一年&#xff0c;轻量应用服务器4核8G配置191.1元3个月、352.8元6个月、646.8元一年&#xff0c;CVM云服务器2核4G配置842.4元一年&…
阅读更多...
基于扩散模型的图像编辑：首篇综述

基于扩散模型的图像编辑：首篇综述

AIGC 大模型最火热的任务之一——基于 Diffusion Model 的图像编辑(editing)领域的首篇综述。长达 26 页&#xff0c;涵盖 297 篇文献&#xff01;本文全面研究图像编辑前沿方法&#xff0c;并根据技术路线精炼地划分为 3 个大类、14 个子类&#xff0c;通过表格列明每个方法的…
阅读更多...
查询缓存-缓存更新-缓存穿透-缓存雪崩-缓存击穿

查询缓存-缓存更新-缓存穿透-缓存雪崩-缓存击穿

1.查询缓存 1.2.出现的原因 用户高并发访问带来的服务器读写的压力 1.3.解决方法 添加缓存 2.缓存更新 2.1.出现的原因 出现数据不一致的问题 2.2.解决方法 操作数据库的时候 更新数据库删除缓存 查询数据的时候设置过期时间 3.缓存穿透 3.1.出现的原因 在高并发访…
阅读更多...
LeetCode 热题 100 | 图论（一）

LeetCode 热题 100 | 图论（一）

目录 1 200. 岛屿数量 2 994. 腐烂的橘子 2.1 智障遍历法 2.2 仿层序遍历法 菜鸟做题&#xff0c;语言是 C 1 200. 岛屿数量 解题思路&#xff1a; 遍历二维数组&#xff0c;寻找 “1”&#xff08;若找到则岛屿数量 1&#xff09;寻找与当前 “1” 直接或间接连接在…
阅读更多...
Java输入输出流详细解析

Java输入输出流详细解析

Java I/O&#xff08;输入/输出&#xff09;主要被用来处理输入数据和输出结果。 在Java中&#xff0c;输入/输出操作被当作流&#xff08;Stream&#xff09;进行处理。流是一个连续的数据流入或数据流出的通道。流操作在Java中主要可以分为两种类型&#xff1a;字节流和字符…
阅读更多...
基于ssm疫情期间高校防控系统+vue论文

基于ssm疫情期间高校防控系统+vue论文

摘 要 传统信息的管理大部分依赖于管理人员的手工登记与管理&#xff0c;然而&#xff0c;随着近些年信息技术的迅猛发展&#xff0c;让许多比较老套的信息管理模式进行了更新迭代&#xff0c;学生信息因为其管理内容繁杂&#xff0c;管理数量繁多导致手工进行处理不能满足广大…
阅读更多...
‘conda‘ 不是内部或外部命令，也不是可运行的程序 或批处理文件

‘conda‘ 不是内部或外部命令，也不是可运行的程序 或批处理文件

如果你在运行 conda 命令时收到了 ‘conda’ 不是内部或外部命令&#xff0c;也不是可运行的程序或批处理文件。 的错误消息&#xff0c;这可能意味着 Anaconda 并没有正确地添加到你的系统路径中。 1.你可以尝试手动添加 Anaconda 到系统路径中。以下是在 Windows 系统上添加…
阅读更多...
19.2 DeepMetricFi:基于深度度量学习改进Wi-Fi指纹定位

19.2 DeepMetricFi:基于深度度量学习改进Wi-Fi指纹定位

P. Chen and S. Zhang, "DeepMetricFi: Improving Wi-Fi Fingerprinting Localization by Deep Metric Learning," in IEEE Internet of Things Journal, vol. 11, no. 4, pp. 6961-6971, 15 Feb.15, 2024, doi: 10.1109/JIOT.2023.3315289. 摘要 Wi-Fi RSSI指纹定位…
阅读更多...
C++内存泄漏：原因、预防、定位

C++内存泄漏：原因、预防、定位

内存泄漏是 C 中常见的问题之一&#xff0c;可能导致程序运行时资源消耗过大、性能下降&#xff0c;甚至程序崩溃。 内存泄漏的原因 1. 未释放动态分配的内存 在 C 中&#xff0c;通过 new 操作符分配的内存需要手动使用 delete 操作符进行释放。如果忘记或者由于某种原因未…
阅读更多...
调用“每日诗词”在你的页面添加一句诗

调用“每日诗词”在你的页面添加一句诗

概述 前几天浏览网站的时候看到页面上有句诗&#xff0c;打开调试看了下调用的是“每日诗词”的SDK。本文基于此SDK实现你的页面添加一句诗。 实现效果 实现 1. 引入SDK <script src"https://sdk.jinrishici.com/v2/browser/jinrishici.js" charset"utf-…
阅读更多...
最新文章

Copyright @ 2022~2023