链表之SLIST
Posted 车子 chezi
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了链表之SLIST相关的知识，希望对你有一定的参考价值。
文章目录
背景
对于 C 语言，在编程中需要用到链表时，通常需要程序员重新设计链表的结构体。这样做不仅麻烦，且需要验证代码的正确性，对于每个阅读代码的人，还需要重新理解。
如果有统一的接口，岂不是更好？
在 FreeBSD 中有 queue.h 这样一个头文件（Linux 也有，文件路径是 /usr/include/x86_64-linux-gnu/sys/queue.h，可以查阅 manual 手册的queue(3) ）。
头文件 queue.h 为 C 语言中的链表提供了更加标准规范的编程接口。如今的版本多为伯克利加州大学1994年8月的8.5版本（8.5 (Berkeley) 8/20/94）。
queue 分为 SLIST、LIST、STAILQ、TAILQ、CIRCLEQ ，不同的链表有着不同的功能支持。queue 的所有源码都是宏定义，因此完全包含于queue.h当中，无需编译为库文件。
我拿到的 queue.h 一共 500 多行，代码会在本文的末尾附上，不同的版本可能不太一样。
建议：如果你想在你的项目中使用它，最好的选择是将你最喜欢的一个复制到你的项目中并使用它。不要依赖操作系统。它只是一个带有一堆宏的头文件，不需要库或任何依赖项即可工作。
SLIST 简介
SLIST 是 Singly-linked List 的缩写，意为单向无尾链表。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WuRai1gC-1644726064142)(pics/image-20220101164926598.png)]
SLIST 是最简单的结构，它适合数据量非常大而几乎不需要删除数据的场合，又或者当做栈使用。
接口和实现
/*
* Singly-linked List declarations.
*/
#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_FOREACH(var, head, field) \\
for ((var) = SLIST_FIRST((head)); \\
(var); \\
(var) = SLIST_NEXT((var), field))
#define SLIST_INIT(head) do \\
SLIST_FIRST((head)) = NULL; \\
while (0)
#define SLIST_INSERT_AFTER(slistelm, elm, field) do \\
SLIST_NEXT((elm), field) = SLIST_NEXT((slistelm), field); \\
SLIST_NEXT((slistelm), field) = (elm); \\
while (0)
#define SLIST_INSERT_HEAD(head, elm, field) do \\
SLIST_NEXT((elm), field) = SLIST_FIRST((head)); \\
SLIST_FIRST((head)) = (elm); \\
while (0)
#define SLIST_NEXT(elm, field) ((elm)->field.sle_next)
#define SLIST_REMOVE(head, elm, type, field) do \\
if (SLIST_FIRST((head)) == (elm)) \\
SLIST_REMOVE_HEAD((head), field); \\
\\
else \\
struct type *curelm = SLIST_FIRST((head)); \\
while (SLIST_NEXT(curelm, field) != (elm)) \\
curelm = SLIST_NEXT(curelm, field); \\
SLIST_NEXT(curelm, field) = \\
SLIST_NEXT(SLIST_NEXT(curelm, field), field); \\
\\
while (0)
#define SLIST_REMOVE_HEAD(head, field) do \\
SLIST_FIRST((head)) = SLIST_NEXT(SLIST_FIRST((head)), field); \\
while (0)
举例
光看代码可能会头晕，我们用例子来说明。
例子来自 https://man7.org/linux/man-pages/man3/SLIST_ENTRY.3.html
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/queue.h>
struct entry
int data;
SLIST_ENTRY(entry) entries;
;
SLIST_HEAD(slisthead, entry);
int main(void)
struct entry *n1, *n2, *n3, *np;
struct slisthead head; /* Singly linked list head */
SLIST_INIT(&head); /* Initialize the queue */
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_REMOVE(&head, n2, entry, entries);/* Deletion */
free(n2);
// 删除第一个节点
n3 = SLIST_FIRST(&head);
SLIST_REMOVE_HEAD(&head, entries); /* Deletion from the head */
free(n3);
for (int i = 0; i < 5; i++)
n1 = malloc(sizeof(struct entry));
SLIST_INSERT_HEAD(&head, n1, entries);
n1->data = i;
/* Forward traversal */
SLIST_FOREACH(np, &head, entries)
printf("%i\\n", np->data);
while (!SLIST_EMPTY(&head)) /* List deletion */
n1 = SLIST_FIRST(&head);
SLIST_REMOVE_HEAD(&head, entries);
free(n1);
SLIST_INIT(&head);
exit(EXIT_SUCCESS);
代码分析
我们一点一点分析。
SLIST_ENTRY 和 SLIST_HEAD
先看结构体的定义
struct entry
int data;
SLIST_ENTRY(entry) entries;
;
SLIST_HEAD(slisthead, entry);
需要注意，上面有 3 个 entry，不管叫什么名字，必须一致；
int data; 是用户数据，根据需要添加；
entries 是
struct struct entry *sle_next;
类型的成员（注：这个结构体没有标签），entries 也可以换成别的名字；
slisthead 是链表头结构体的标签名。
宏替换后就是
struct entry
int data;
struct
struct entry *sle_next;
entries;
;
struct slisthead
struct entry *slh_first;
;
可以看到，和我们初学时定义的不太一样，初学者不太可能把第 4、9 行用结构体包起来。
SLIST_INIT
我们继续看。
struct entry *n1, *n2, *n3, *np;
struct slisthead head; /* Singly linked list head */
SLIST_INIT(&head); /* Initialize the queue */
1：定义了 3 个指向节点的指针；
2：定义表示表头的结构体变量 head，slisthead 要和前面的一致；
3：宏替换后是 (&head)->slh_first = NULL; 意思是初始化为一个空的链表，头指针指向 NULL
SLIST_INSERT_HEAD
n1 = malloc(sizeof(struct entry)); /* Insert at the head */
SLIST_INSERT_HEAD(&head, n1, entries);
1：为节点分配内存，这里省略了对返回指的检查；
2：宏替换后是
(n1)->entries.sle_next = (&head)->slh_first;
(&head)->slh_first = (n1);
典型的头插。SLIST_INSERT_HEAD(&head, n1, entries) 的意思是：把 n1 节点插入到链表 head 的头部；第一个参数是表头的地址，第二参数是待插入的节点的地址，第三个参数是无标签结构体的成员名，和之前的要一致。
SLIST_INSERT_AFTER
n2 = malloc(sizeof(struct entry)); /* Insert after */
SLIST_INSERT_AFTER(n1, n2, entries);
2：宏替换后是
(n2)->entries.sle_next = (n1)->entries.sle_next;
(n1)->entries.sle_next = (n2);
用大白话说就是把 n1 后面的节点接在 n2 后面，再把 n2 接到 n1 后面，所以：
SLIST_INSERT_AFTER(n1, n2, entries) 的意思是把节点 n2 插入到 n1 的后面。n1、n2 都是节点的地址，entries 是无标签结构体的成员名，和之前的要一致。
SLIST_REMOVE
SLIST_REMOVE(&head, n2, entry, entries);/* Deletion */
free(n2);
这个宏替换有点复杂：
if ((&head)->slh_first == (n2))
((&head))->slh_first = ((&head))->slh_first->entries.sle_next;
else
struct entry *curelm = (&head)->slh_first;
while(curelm->entries.sle_next != (n2))
curelm = curelm->entries.sle_next;
curelm->entries.sle_next = curelm->entries.sle_next->entries.sle_next;
1：看看要删除的节点是不是第一个节点，如果是，就删除；如果不是，走 else 分支
5：取第一个节点为当前节点
6：判断当前节点的下一个节点是不是要删除的节点，如果是，while 语句结束，执行第 8 行，删除之。
总结，SLIST_REMOVE(&head, n2, entry, entries) 的意思是：
第一个参数是表头的地址，第二参数是待删除的节点的地址，第三和第四个参数要和最开始定义结构体的时候保持一致，比如 SLIST_ENTRY(entry) entries 中的 entry、entries
SLIST_FIRST 和 SLIST_REMOVE_HEAD
n3 = SLIST_FIRST(&head);
SLIST_REMOVE_HEAD(&head, entries); /* Deletion from the head */
free(n3);
宏替换是：
n3 = ((&head)->slh_first);
(&head)->slh_first = (&head)->slh_first->entries.sle_next;
SLIST_FIRST (&head) 这个宏就是取第一个节点的地址，参数是表头的地址；
2：删除第一个节点
为什么会有第 1 行呢？如果不在这个时候保存第一个节点的地址，那么删除后，就无法获得其地址了，也就无法执行第 3 行的释放空间了。所以，这个例子给我们提供了标准的头删操作。
SLIST_REMOVE_HEAD(&head, entries) 这个宏的意思是删除第一个节点，第一个参数是表头的地址，entries 是无标签结构体的成员名，和之前的要一致。
SLIST_FOREACH
for (int i = 0; i < 5; i++)
n1 = malloc(sizeof(struct entry));
SLIST_INSERT_HEAD(&head, n1, entries);
n1->data = i;
/* Forward traversal */
SLIST_FOREACH(np, &head, entries)
printf("%i\\n", np->data);
3：SLIST_INSERT_HEAD 这个在前面说了，就是头插
4：宏替换后，是
for((np) = (&head)->slh_first; (np); (np) = (np)->entries.sle_next)
printf("%i\\n", np->data);
典型的遍历。注意，这种遍历是不能删除的，因为如果把 np 指向的节点删除了，
(np)->entries.sle_next 这句就不对了。
SLIST_FOREACH(np, &head, entries) 用来遍历链表的每个节点。第一个参数是临时变量，指向当前的节点，第二个参数是表头的地址，第三个 entries 是无标签结构体的成员名，和之前的一致。
这个例子就这一个地方是有打印，打印的结果是：
4
3
2
1
0
因为是头插，所以先插入的会在链表的末尾。遍历的顺序是从头到尾，所以顺序是 4，3，2，1，0
SLIST_EMPTY 和 SLIST_INIT
while (!SLIST_EMPTY(&head)) /* List deletion */
n1 = SLIST_FIRST(&head);
SLIST_REMOVE_HEAD(&head, entries);
free(n1);
2-4 行就不解释了，前文说过了。
SLIST_EMPTY(&head) 宏展开是：
(&head)->slh_first == NULL，就是判断链表是否为空。
附录 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.
* 4. 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
* $FreeBSD: src/sys/sys/queue.h,v 1.32.2.7 2002/04/17 14:21:02 des Exp $
*/
#ifndef _QUEUE_H_
#define _QUEUE_H_
#ifdef __cplusplus
extern "C"
#endif
/*
* This file defines five types of data structures: singly-linked lists,
* singly-linked tail queues, lists, 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 singly-linked 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
* 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, at the head of the list, or at the
* end of the list. Elements being removed from the head of the tail queue
* should use the explicit macro for this purpose for optimum efficiency.
* A singly-linked tail queue may only be traversed in the forward direction.
* Singly-linked tail queues are ideal for applications with large datasets
* and few or no removals or for implementing a FIFO 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 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.
*
*
* SLIST LIST STAILQ TAILQ CIRCLEQ
* _HEAD + + + + +
* _HEAD_INITIALIZER + + + + +
* _ENTRY + + + + +
* _INIT + + + + +
* _EMPTY + + + + +
* _FIRST + + + + +
* _NEXT + + + + +
* _PREV - - - + +
* _LAST - - + + +
* _FOREACH + + + + +
* _FOREACH_REVERSE - - - + +
* _INSERT_HEAD + + + + +
* _INSERT_BEFORE - + - + +
* _INSERT_AFTER + + + + +
* _INSERT_TAIL - - + + +
* _REMOVE_HEAD + - + - -
* _REMOVE + + + + +
*
*/
/*
* Singly-linked List declarations.
*/
#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_FOREACH(var, head, field) \\
for ((var) = SLIST_FIRST((head)); \\
(var); \\
(var) = SLIST_NEXT((var), field))
#define SLIST_INIT(head) do \\
SLIST_FIRST((head)) = NULL; \\
while (0)
#define SLIST_INSERT_AFTER(slistelm, elm, field) do \\
SLIST_NEXT((elm), field) = SLIST_NEXT链表之SLIST