【数据结构】list.h 详细使用教程 -- 附带例子代码

已于 2024-04-13 12:14:02 修改
阅读量1k 收藏 9
点赞数 4
分类专栏： 数据结构与算法 文章标签： 数据结构 list windows
于 2023-09-24 23:13:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wkd_007/article/details/133250211
版权

目录

相关文章：
【数据结构】list.h 常用函数实现详解
【数据结构】list.h 详细使用教程 – 附带例子代码

在这里插入图片描述

一、概述

前面文章【数据结构】list.h 常用函数实现详解 介绍过 list.h 的函数实现，这篇文章打算结束一下 list.h 的使用步骤，基本步骤有下面几个：

    1. 定义结构体时必须包含 struct list_head 成员
    1. 初始化链表头结点：
      INIT_LIST_HEAD(&studentsList);
    1. 添加结点：
      list_add(&pXiaoMing->list_node, &studentsList); // 链表头部插入
      list_add_tail(&pZero->list_node, &studentsList); // 链表尾部插入
    1. 遍历链表：
      list_for_each_safe(pos,tmp,listHead) // 对列表进行迭代，以防删除列表条目。
      list_for_each_entry(pListEntry, listHead, list_node) // 迭代给定类型的列表，遍历各个条目
      list_for_each(pos,listHead) // 对列表进行迭代，一般用 list_for_each_safe
    1. 获取结构体数据：
      list_entry(pos,stStudentData,list_node); // 获取当前 struct list_head 的结构体指针
      list_entry(studentsList.next,stStudentData,list_node); // 链表第一个结构体指针
      list_entry(studentsList.prev,stStudentData,list_node); // 链表最后一个结构体指针
      == 注意== ：获取结构体指针之前，需要先判断链表是否为空，list_entry在空链表依然可以获取到数据，这显然不是想要的结果
    1. 删除结点
      list_del(pos); // 从列表中删除条目。
    1. 判断是否空链表
      list_empty(list); // 判断空链表

在这里插入图片描述

二、详细使用步骤

✨2.1 定义结构体包含 struct list_head 成员

list.h 添加和删除结点都是通过操作struct list_head指针的，所以结点的结构体必须包含struct list_head成员。struct list_head成员一般放在结构体的最后一个，比较显眼，但这不是必须的。可以参考下面代码定义链表结点结构体：

// 1、定义的结构体必须包含 struct list_head 成员，才可以作为链表结点 2023-09-23 21:30:14
typedef struct studentData
{
	int age;
	int num;
	struct list_head list_node;
	char gender[10];
	char name[10];
}stStudentData, *pstStudentData;

✨2.2 初始化链表头结点：INIT_LIST_HEAD

list.h是带有头结点的，并且操作链表时，很多时候也需要头结点。可以参考下面代码定义并初始化头结点：

// 2、定义并初始化头结点
struct list_head studentsList;// 头结点
INIT_LIST_HEAD(&studentsList);

✨2.3 添加结点：list_add、list_add_tail

初始化头结点后，就可以添加结点了，list.h 提供了两种方式添加结点：头部添加、尾部添加，可以参考下面代码添加自己结点：

// 3.1、在链表头部插入数据 list_add
pstStudentData pXiaoMing=(pstStudentData)malloc(sizeof(stStudentData));
pXiaoMing->age = 10;
pXiaoMing->num = 1;
sprintf(pXiaoMing->gender,"%s","boy");
sprintf(pXiaoMing->name,"%s","XiaoMing");
list_add(&pXiaoMing->list_node, &studentsList);

pstStudentData pXiaoHua=(pstStudentData)malloc(sizeof(stStudentData));
pXiaoHua->age = 11;
pXiaoHua->num = 2;
sprintf(pXiaoHua->gender,"%s","girl");
sprintf(pXiaoHua->name,"%s","XiaoHua");
list_add(&pXiaoHua->list_node, &studentsList);

// 3.2、在链表尾部插入数据 list_add_tail
pstStudentData pZero=(pstStudentData)malloc(sizeof(stStudentData));
pZero->age = 8;
pZero->num = 0;
sprintf(pZero->gender,"%s","boy");
sprintf(pZero->name,"%s","zero");
list_add_tail(&pZero->list_node, &studentsList);

✨2.4 遍历链表：list_for_each、list_for_each_safe、list_for_each_entry

  • list_for_each(pos, head)：是一个宏，展开后是for循环，pos是作为迭代指针，指向各个结点；
  • list_for_each_safe(pos, n, head)：与list_for_each一样，可以防止误删结点，较常用；
  • list_for_each_entry(pos, head, member)：可以直接迭代访问结构体类型，pos指向结构体类型地址。

使用方法参考下面代码：

// 4、遍历链表
void print_list(struct list_head *listHead)
{
	struct list_head *pos,*tmp;
	pstStudentData pListEntry;	// 链表条目 2023-09-23 22:07:14
	list_for_each(pos,listHead)
	{
		pListEntry = list_entry(pos,stStudentData,list_node); 
		printf("list_for_each: num=%d, name=[%s], gender=[%s], age=%d, \n",
			pListEntry->num, pListEntry->name, pListEntry->gender, pListEntry->age);
	}
	
	/*
	* 对列表进行迭代，以防删除列表条目。
	* pos:	要用作循环计数器的&struct list_head。指向迭代的条目的指针;
	* tmp:	另一个 &struct list_head, 用作临时存储(外部没作用);
	* listHead: 链表头指针  2023-09-23 22:18:11
	*/
	list_for_each_safe(pos,tmp,listHead) 
	{
		/*
		* 获取当前 struct list_head 的结构体指针
		* pos:	struct list_head指针。
		* stStudentData: 包含 struct list_head 的结构体类型名称
		* list_node: 结构中 struct list_head 的成员名称。
		*/
		// 5. 获取当前 struct list_head 的结构体指针
		pListEntry = list_entry(pos,stStudentData,list_node); 
		printf("list_for_each_safe: num=%d, name=[%s], gender=[%s], age=%d, \n",
			pListEntry->num, pListEntry->name, pListEntry->gender, pListEntry->age);
	}
	
	/*
	* 迭代给定类型的列表
	* pListEntry:	要用作循环计数器的类型指针
	* listHead:		链表头指针  2023-09-23 22:18:11
	* list_node:	结构中list_struct的名称。
	*/
	list_for_each_entry(pListEntry, listHead, list_node)
	{
		printf("list_for_each_entry: num=%d, name=[%s], gender=[%s], age=%d, \n",
			pListEntry->num, pListEntry->name, pListEntry->gender, pListEntry->age);
	}
}

✨2.5 获取结构体数据：list_entry

list_entry 可以通过 struct list_head*指针获取到结构体的首地址，进而对结构体数据进行访问；
注意：获取结构体指针之前，需要先判断链表是否为空，list_entry在空链表依然可以获取到数据，这显然不是想要的结果。

list_entry(ptr, type, member)
函数参数：

  • ptr: struct list_head指针。
  • type: 包含 struct list_head 的结构体类型名称
  • member: 结构中 struct list_head 的成员名称。

使用方法参考下面代码：

// 5.获取结构体数据 2023-09-24 21:18:02
pstStudentData pFirst = list_entry(studentsList.next,stStudentData,list_node);
//pstStudentData pFirst = list_first_entry(&studentsList,stStudentData,list_node);
printf("pFirst: num=%d, name=[%s], gender=[%s], age=%d, \n",
	pFirst->num, pFirst->name, pFirst->gender, pFirst->age);
			
pstStudentData pLast = list_entry(studentsList.prev,stStudentData,list_node);
//pstStudentData pLast = list_last_entry(&studentsList,stStudentData,list_node);
printf("pLast: num=%d, name=[%s], gender=[%s], age=%d, \n",
	pLast->num, pLast->name, pLast->gender, pLast->age);

✨2.6 删除结点：list_del

list_del 函数可以删除指定的结点。使用方法参考下面代码：

void clear_list(struct list_head *listHead)
{
	struct list_head *pos,*tmp;
	pstStudentData pListEntry;	// 链表条目 2023-09-23 22:07:14

	list_for_each_safe(pos,tmp,listHead) 
	{
		pListEntry = list_entry(pos,stStudentData,list_node); 
		printf("del: num=%d, name=[%s], gender=[%s], age=%d, \n",
			pListEntry->num, pListEntry->name, pListEntry->gender, pListEntry->age);
		/*
		* 从列表中删除条目。
		* pos: 要从列表中删除的元素。struct list_head *
		*/
		list_del(pos);
		free(pListEntry);
	}
}

✨2.7 判断是否空链表：list_empty

list_empty：只需要传入链表头结点，就可以判断链表是否为空，为空返回真，不空返回假；
使用方法参考下面代码：

// 7.判断空链表
if(list_empty(&studentsList))
{
	pstStudentData pFirst = list_entry(studentsList.next,stStudentData,list_node);
	
	if(pFirst==NULL)
		printf("list is empty\n");
	else
		printf("list is empty,error fist %p\n", pFirst);
}

在这里插入图片描述

三、list.h 使用例子源码

将前面的示例代码整合起来就是一个使用 list.h 例子，代码如下：

// list_sample.c
/*
* 演示 list.h 的使用

* 1. 结构体必须包含 struct list_head 成员

* 2. INIT_LIST_HEAD(&studentsList); // 初始化链表头结点

* 3. list_add(&pXiaoMing->list_node, &studentsList);  // 链表头部插入

* 4. list_add_tail(&pZero->list_node, &studentsList);  // 链表尾部插入

* 5. list_for_each_safe(pos,tmp,listHead) // 对列表进行迭代，以防删除列表条目。
     list_for_each_entry(pListEntry, listHead, list_node) // 迭代给定类型的列表，遍历各个条目
	 list_for_each(pos,listHead)  // 对列表进行迭代，一般用 list_for_each_safe
	 
* 6. list_entry(pos,stStudentData,list_node); // 获取当前 struct list_head 的结构体指针
     list_entry(studentsList.next,stStudentData,list_node); // 链表第一个结构体指针
     list_entry(studentsList.prev,stStudentData,list_node); // 链表最后一个结构体指针
	 注意：获取结构体指针之前，需要先判断链表是否为空，list_entry在空链表依然可以获取到数据，这显然不是想要的结果
	 
* 7. list_del(pos); // 从列表中删除条目。

* 8. list_empty(list) // 判断空链表

*/

#include <stdio.h>
#include <stdlib.h>
#include "list.h" // 包含 list.h
//#include "my_list.h" // 包含 my_list.h

#define list_first_entry(ptr, type, member) \
	list_entry((ptr)->next, type, member)
	
#define list_last_entry(ptr, type, member) \
	list_entry((ptr)->prev, type, member)

// 1、定义的结构体必须包含 struct list_head 成员，才可以作为链表结点 2023-09-23 21:30:14
typedef struct studentData
{
	int age;
	int num;
	struct list_head list_node;
	char gender[10];
	char name[10];
}stStudentData, *pstStudentData;

// 4、遍历链表
void print_list(struct list_head *listHead)
{
	struct list_head *pos,*tmp;
	pstStudentData pListEntry;	// 链表条目 2023-09-23 22:07:14
	list_for_each(pos,listHead)
	{
		pListEntry = list_entry(pos,stStudentData,list_node); 
		printf("list_for_each: num=%d, name=[%s], gender=[%s], age=%d, \n",
			pListEntry->num, pListEntry->name, pListEntry->gender, pListEntry->age);
	}
	
	/*
	* 对列表进行迭代，以防删除列表条目。
	* pos:	要用作循环计数器的&struct list_head。指向迭代的条目的指针;
	* tmp:	另一个 &struct list_head, 用作临时存储(外部没作用);
	* listHead: 链表头指针  2023-09-23 22:18:11
	*/
	list_for_each_safe(pos,tmp,listHead) 
	{
		/*
		* 获取当前 struct list_head 的结构体指针
		* pos:	struct list_head指针。
		* stStudentData: 包含 struct list_head 的结构体类型名称
		* list_node: 结构中 struct list_head 的成员名称。
		*/
		// 6. 获取当前 struct list_head 的结构体指针
		pListEntry = list_entry(pos,stStudentData,list_node); 
		printf("list_for_each_safe: num=%d, name=[%s], gender=[%s], age=%d, \n",
			pListEntry->num, pListEntry->name, pListEntry->gender, pListEntry->age);
	}
	
	/*
	* 迭代给定类型的列表
	* pListEntry:	要用作循环计数器的类型指针
	* listHead:		链表头指针  2023-09-23 22:18:11
	* list_node:	结构中list_struct的名称。
	*/
	list_for_each_entry(pListEntry, listHead, list_node)
	{
		printf("list_for_each_entry: num=%d, name=[%s], gender=[%s], age=%d, \n",
			pListEntry->num, pListEntry->name, pListEntry->gender, pListEntry->age);
	}
}

void clear_list(struct list_head *listHead)
{
	struct list_head *pos,*tmp;
	pstStudentData pListEntry;	// 链表条目 2023-09-23 22:07:14

	list_for_each_safe(pos,tmp,listHead) 
	{
		pListEntry = list_entry(pos,stStudentData,list_node); 
		printf("del: num=%d, name=[%s], gender=[%s], age=%d, \n",
			pListEntry->num, pListEntry->name, pListEntry->gender, pListEntry->age);
		/*
		* 从列表中删除条目。
		* pos: 要从列表中删除的元素。struct list_head *
		*/
		list_del(pos);
		free(pListEntry);
	}
}

int main()
{
	// 2、定义并初始化头结点
	struct list_head studentsList;// 头结点
	INIT_LIST_HEAD(&studentsList);
	//INIT_LIST_HEAD(NULL);
	
	// 3.1、在链表头部插入数据 list_add
	pstStudentData pXiaoMing=(pstStudentData)malloc(sizeof(stStudentData));
	pXiaoMing->age = 10;
	pXiaoMing->num = 1;
	sprintf(pXiaoMing->gender,"%s","boy");
	sprintf(pXiaoMing->name,"%s","XiaoMing");
	list_add(&pXiaoMing->list_node, &studentsList);
	
	pstStudentData pXiaoHua=(pstStudentData)malloc(sizeof(stStudentData));
	pXiaoHua->age = 11;
	pXiaoHua->num = 2;
	sprintf(pXiaoHua->gender,"%s","girl");
	sprintf(pXiaoHua->name,"%s","XiaoHua");
	list_add(&pXiaoHua->list_node, &studentsList);
	
	// 3.2、在链表尾部插入数据 list_add_tail
	pstStudentData pZero=(pstStudentData)malloc(sizeof(stStudentData));
	pZero->age = 8;
	pZero->num = 0;
	sprintf(pZero->gender,"%s","boy");
	sprintf(pZero->name,"%s","zero");
	list_add_tail(&pZero->list_node, &studentsList);
	
	// 4、遍历链表
	print_list(&studentsList);
	
	// 5.获取结构体数据 2023-09-24 21:18:02
	pstStudentData pFirst = list_entry(studentsList.next,stStudentData,list_node);
	//pstStudentData pFirst = list_first_entry(&studentsList,stStudentData,list_node);
	printf("pFirst: num=%d, name=[%s], gender=[%s], age=%d, \n",
			pFirst->num, pFirst->name, pFirst->gender, pFirst->age);
			
	pstStudentData pLast = list_entry(studentsList.prev,stStudentData,list_node);
	//pstStudentData pLast = list_last_entry(&studentsList,stStudentData,list_node);
	printf("pLast: num=%d, name=[%s], gender=[%s], age=%d, \n",
			pLast->num, pLast->name, pLast->gender, pLast->age);
	
	
	// 6.clear_list
	clear_list(&studentsList);
	
	// 7.判断空链表
	if(list_empty(&studentsList))
	{
		pstStudentData pFirst = list_entry(studentsList.next,stStudentData,list_node);
		
		if(pFirst==NULL)
			printf("list is empty\n");
		else
			printf("list is empty,error fist %p\n", pFirst);
	}
	return 0;
}

在这里插入图片描述

四、例子中使用的 list.h 代码

// list.h
#ifndef _LINUX_LIST_H
#define _LINUX_LIST_H


/*
   prefetch(x) attempts to pre-emptively get the memory pointed to
   by address "x" into the CPU L1 cache. 
   prefetch(x) should not cause any kind of exception, prefetch(0) is
   specifically ok.

   prefetch() should be defined by the architecture, if not, the 
#define below provides a no-op define.	

There are 3 prefetch() macros:

prefetch(x)  	- prefetches the cacheline at "x" for read
prefetchw(x)	- prefetches the cacheline at "x" for write
spin_lock_prefetch(x) - prefectches the spinlock *x for taking

there is also PREFETCH_STRIDE which is the architecure-prefered 
"lookahead" size for prefetching streamed operations.

*/

/*
 *	These cannot be do{}while(0) macros. See the mental gymnastics in
 *	the loop macro.
 */

#ifndef ARCH_HAS_PREFETCH
static inline void prefetch(const void *x) {;}
#endif

#ifndef ARCH_HAS_PREFETCHW
static inline void prefetchw(const void *x) {;}
#endif

#ifndef ARCH_HAS_SPINLOCK_PREFETCH
#define spin_lock_prefetch(x) prefetchw(x)
#endif

#ifndef PREFETCH_STRIDE
#define PREFETCH_STRIDE (4*L1_CACHE_BYTES)
#endif

static inline void prefetch_range(void *addr, size_t len)
{
#ifdef ARCH_HAS_PREFETCH
	char *cp;
	char *end = addr + len;

	for (cp = addr; cp < end; cp += PREFETCH_STRIDE)
		prefetch(cp);
#endif
}

/*
 * These are non-NULL pointers that will result in page faults
 * under normal circumstances, used to verify that nobody uses
 * non-initialized list entries.
 */
#define LIST_POISON1  ((void *) 0x00100100)
#define LIST_POISON2  ((void *) 0x00200200)

/*
 * Simple doubly linked list implementation.
 *
 * Some of the internal functions ("__xxx") are useful when
 * manipulating whole lists rather than single entries, as
 * sometimes we already know the next/prev entries and we can
 * generate better code by using them directly rather than
 * using the generic single-entry routines.
 */

struct list_head {
	struct list_head *next, *prev;
};

#define LIST_HEAD_INIT(name) { &(name), &(name) }

#define LIST_HEAD(name) \
	struct list_head name = LIST_HEAD_INIT(name)

#define INIT_LIST_HEAD(ptr) do { \
	(ptr)->next = (ptr); (ptr)->prev = (ptr); \
} while (0)

/*
 * Insert a new entry between two known consecutive entries.
 *
 * This is only for internal list manipulation where we know
 * the prev/next entries already!
 */
static inline void __list_add(struct list_head *new_node,
		struct list_head *prev,
		struct list_head *next)
{
	next->prev = new_node;
	new_node->next = next;
	new_node->prev = prev;
	prev->next = new_node;
}

/**
 * list_add - add a new entry
 * @new: new entry to be added
 * @head: list head to add it after
 *
 * Insert a new entry after the specified head.
 * This is good for implementing stacks.
 */
static inline void list_add(struct list_head *new_node, struct list_head *head)
{
	__list_add(new_node, head, head->next);
}

/**
 * list_add_tail - add a new entry
 * @new: new entry to be added
 * @head: list head to add it before
 *
 * Insert a new entry before the specified head.
 * This is useful for implementing queues.
 */
static inline void list_add_tail(struct list_head *new_node, struct list_head *head)
{
	__list_add(new_node, head->prev, head);
}

/*
 * Delete a list entry by making the prev/next entries
 * point to each other.
 *
 * This is only for internal list manipulation where we know
 * the prev/next entries already!
 */
static inline void __list_del(struct list_head * prev, struct list_head * next)
{
	next->prev = prev;
	prev->next = next;
}

/**
 * list_del - deletes entry from list.
 * @entry: the element to delete from the list.
 * Note: list_empty on entry does not return true after this, the entry is
 * in an undefined state.
 */
static inline void list_del(struct list_head *entry)
{
	__list_del(entry->prev, entry->next);
	//entry->next = (struct list_head *)LIST_POISON1;
	//entry->prev = (struct list_head *)LIST_POISON2;
}

/**
 * list_del_init - deletes entry from list and reinitialize it.
 * @entry: the element to delete from the list.
 */
static inline void list_del_init(struct list_head *entry)
{
	__list_del(entry->prev, entry->next);
	INIT_LIST_HEAD(entry);
}

/**
 * list_move - delete from one list and add as another's head
 * @list: the entry to move
 * @head: the head that will precede our entry
 */
static inline void list_move(struct list_head *list, struct list_head *head)
{
	__list_del(list->prev, list->next);
	list_add(list, head);
}

/**
 * list_move_tail - delete from one list and add as another's tail
 * @list: the entry to move
 * @head: the head that will follow our entry
 */
static inline void list_move_tail(struct list_head *list,
		struct list_head *head)
{
	__list_del(list->prev, list->next);
	list_add_tail(list, head);
}

/**
 * list_empty - tests whether a list is empty
 * @head: the list to test.
 */
static inline int list_empty(const struct list_head *head)
{
	return head->next == head;
}

/**
 * list_empty_careful - tests whether a list is
 * empty _and_ checks that no other CPU might be
 * in the process of still modifying either member
 *
 * NOTE: using list_empty_careful() without synchronization
 * can only be safe if the only activity that can happen
 * to the list entry is list_del_init(). Eg. it cannot be used
 * if another CPU could re-list_add() it.
 *
 * @head: the list to test.
 */
static inline int list_empty_careful(const struct list_head *head)
{
	struct list_head *next = head->next;
	return (next == head) && (next == head->prev);
}

static inline void __list_splice(struct list_head *list,
		struct list_head *head)
{
	struct list_head *first = list->next;
	struct list_head *last = list->prev;
	struct list_head *at = head->next;

	first->prev = head;
	head->next = first;

	last->next = at;
	at->prev = last;
}
static inline void __list_splice_tail(struct list_head *list,
		struct list_head *head)
{
	struct list_head *last = list->prev;
	struct list_head *first  = list->next;
	struct list_head *at = head->prev;

	head->prev = last;
	last->next = head;

	first->prev = at;
	at->next = first;

}

/**
 * list_splice - join two lists
 * @list: the new list to add.
 * @head: the place to add it in the first list.
 */
static inline void list_splice(struct list_head *list, struct list_head *head)
{
	if (!list_empty(list))
		__list_splice(list, head);
}

static inline void list_splice_tail(struct list_head *list, struct list_head *head)
{
	if(!list_empty(list))
		__list_splice_tail(list, head);

}
/**
 * list_splice_init - join two lists and reinitialise the emptied list.
 * @list: the new list to add.
 * @head: the place to add it in the first list.
 *
 * The list at @list is reinitialised
 */
static inline void list_splice_init(struct list_head *list,
		struct list_head *head)
{
	if (!list_empty(list)) {
		__list_splice(list, head);
		INIT_LIST_HEAD(list);
	}
}

#ifndef offsetof
#define offsetof(type, f) ((size_t) \
		((char *)&((type *)0)->f - (char *)(type *)0))
#endif

#ifndef container_of
#define container_of(ptr, type, member) ({ \
		const typeof( ((type *)0)->member ) *__mptr = (ptr);\
		(type *)( (char *)__mptr - offsetof(type,member) );})
#endif




/**
 * list_entry - get the struct for this entry
 * @ptr:	the &struct list_head pointer.
 * @type:	the type of the struct this is embedded in.
 * @member:	the name of the list_struct within the struct.
 */
#define list_entry(ptr, type, member) \
	container_of(ptr, type, member)

/**
 * list_for_each	-	iterate over a list
 * @pos:	the &struct list_head to use as a loop counter.
 * @head:	the head for your list.
 */
#define list_for_each(pos, head) \
	for (pos = (head)->next; prefetch(pos->next), pos != (head); \
			pos = pos->next)

/**
 * __list_for_each	-	iterate over a list
 * @pos:	the &struct list_head to use as a loop counter.
 * @head:	the head for your list.
 *
 * This variant differs from list_for_each() in that it's the
 * simplest possible list iteration code, no prefetching is done.
 * Use this for code that knows the list to be very short (empty
 * or 1 entry) most of the time.
 */
#define __list_for_each(pos, head) \
	for (pos = (head)->next; pos != (head); pos = pos->next)

/**
 * list_for_each_prev	-	iterate over a list backwards
 * @pos:	the &struct list_head to use as a loop counter.
 * @head:	the head for your list.
 */
#define list_for_each_prev(pos, head) \
	for (pos = (head)->prev; prefetch(pos->prev), pos != (head); \
			pos = pos->prev)

/**
 * list_for_each_safe	-	iterate over a list safe against removal of list entry
 * @pos:	the &struct list_head to use as a loop counter.
 * @n:		another &struct list_head to use as temporary storage
 * @head:	the head for your list.
 */
#define list_for_each_safe(pos, n, head) \
	for (pos = (head)->next, n = pos->next; pos != (head); \
			pos = n, n = pos->next)


#define get_first_item(attached, type, member) \
    ((type *)((char *)((attached)->next)-(unsigned long)(&((type *)0)->member)))


/**
 * list_for_each_entry	-	iterate over list of given type
 * @pos:	the type * to use as a loop counter.
 * @head:	the head for your list.
 * @member:	the name of the list_struct within the struct.
 */
#define list_for_each_entry(pos, head, member)				\
	for (pos = list_entry((head)->next, typeof(*pos), member);	\
			prefetch(pos->member.next), &pos->member != (head); 	\
			pos = list_entry(pos->member.next, typeof(*pos), member))

/**
 * list_for_each_entry_reverse - iterate backwards over list of given type.
 * @pos:	the type * to use as a loop counter.
 * @head:	the head for your list.
 * @member:	the name of the list_struct within the struct.
 */
#define list_for_each_entry_reverse(pos, head, member)			\
	for (pos = list_entry((head)->prev, typeof(*pos), member);	\
			prefetch(pos->member.prev), &pos->member != (head); 	\
			pos = list_entry(pos->member.prev, typeof(*pos), member))

/**
 * list_prepare_entry - prepare a pos entry for use as a start point in
 *			list_for_each_entry_continue
 * @pos:	the type * to use as a start point
 * @head:	the head of the list
 * @member:	the name of the list_struct within the struct.
 */
#define list_prepare_entry(pos, head, member) \
	((pos) ? : list_entry(head, typeof(*pos), member))

/**
 * list_for_each_entry_continue -	iterate over list of given type
 *			continuing after existing point
 * @pos:	the type * to use as a loop counter.
 * @head:	the head for your list.
 * @member:	the name of the list_struct within the struct.
 */
#define list_for_each_entry_continue(pos, head, member) 		\
	for (pos = list_entry(pos->member.next, typeof(*pos), member);	\
			prefetch(pos->member.next), &pos->member != (head);	\
			pos = list_entry(pos->member.next, typeof(*pos), member))

/**
 * list_for_each_entry_safe - iterate over list of given type safe against removal of list entry
 * @pos:	the type * to use as a loop counter.
 * @n:		another type * to use as temporary storage
 * @head:	the head for your list.
 * @member:	the name of the list_struct within the struct.
 */
#define list_for_each_entry_safe(pos, n, head, member)			\
	for (pos = list_entry((head)->next, typeof(*pos), member),	\
			n = list_entry(pos->member.next, typeof(*pos), member);	\
			&pos->member != (head); 					\
			pos = n, n = list_entry(n->member.next, typeof(*n), member))

/**
 * list_for_each_entry_safe_continue -	iterate over list of given type
 *			continuing after existing point safe against removal of list entry
 * @pos:	the type * to use as a loop counter.
 * @n:		another type * to use as temporary storage
 * @head:	the head for your list.
 * @member:	the name of the list_struct within the struct.
 */
#define list_for_each_entry_safe_continue(pos, n, head, member) 		\
	for (pos = list_entry(pos->member.next, typeof(*pos), member), 		\
			n = list_entry(pos->member.next, typeof(*pos), member);		\
			&pos->member != (head);						\
			pos = n, n = list_entry(n->member.next, typeof(*n), member))

/*
 * Double linked lists with a single pointer list head.
 * Mostly useful for hash tables where the two pointer list head is
 * too wasteful.
 * You lose the ability to access the tail in O(1).
 */

struct hlist_head {
	struct hlist_node *first;
};

struct hlist_node {
	struct hlist_node *next, **pprev;
};

#define HLIST_HEAD_INIT { .first = NULL }
#define HLIST_HEAD(name) struct hlist_head name = {  .first = NULL }
#define INIT_HLIST_HEAD(ptr) ((ptr)->first = NULL)
#define INIT_HLIST_NODE(ptr) ((ptr)->next = NULL, (ptr)->pprev = NULL)

static inline int hlist_unhashed(const struct hlist_node *h)
{
	return !h->pprev;
}

static inline int hlist_empty(const struct hlist_head *h)
{
	return !h->first;
}

static inline void __hlist_del(struct hlist_node *n)
{
	struct hlist_node *next = n->next;
	struct hlist_node **pprev = n->pprev;
	*pprev = next;
	if (next)
		next->pprev = pprev;
}

static inline void hlist_del(struct hlist_node *n)
{
	__hlist_del(n);
	n->next = (struct hlist_node *)LIST_POISON1;
	n->pprev = (struct hlist_node **)LIST_POISON2;
}


static inline void hlist_del_init(struct hlist_node *n)
{
	if (n->pprev)  {
		__hlist_del(n);
		INIT_HLIST_NODE(n);
	}
}

static inline void hlist_add_head(struct hlist_node *n, struct hlist_head *h)
{
	struct hlist_node *first = h->first;
	n->next = first;
	if (first)
		first->pprev = &n->next;
	h->first = n;
	n->pprev = &h->first;
}




/* next must be != NULL */
static inline void hlist_add_before(struct hlist_node *n,
		struct hlist_node *next)
{
	n->pprev = next->pprev;
	n->next = next;
	next->pprev = &n->next;
	*(n->pprev) = n;
}

static inline void hlist_add_after(struct hlist_node *n,
		struct hlist_node *next)
{
	next->next = n->next;
	n->next = next;
	next->pprev = &n->next;

	if(next->next)
		next->next->pprev  = &next->next;
}


#define hlist_entry(ptr, type, member) container_of(ptr,type,member)

#define hlist_for_each(pos, head) \
	for (pos = (head)->first; pos && ({ prefetch(pos->next); 1; }); \
			pos = pos->next)

#define hlist_for_each_safe(pos, n, head) \
	for (pos = (head)->first; pos && ({ n = pos->next; 1; }); \
			pos = n)
/**
 * hlist_for_each_entry	- iterate over list of given type
 * @tpos:	the type * to use as a loop counter.
 * @pos:	the &struct hlist_node to use as a loop counter.
 * @head:	the head for your list.
 * @member:	the name of the hlist_node within the struct.
 */
#define hlist_for_each_entry(tpos, pos, head, member)			 \
	for (pos = (head)->first;					 \
			pos && ({ prefetch(pos->next); 1;}) &&			 \
			({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
			pos = pos->next)

/**
 * hlist_for_each_entry_continue - iterate over a hlist continuing after existing point
 * @tpos:	the type * to use as a loop counter.
 * @pos:	the &struct hlist_node to use as a loop counter.
 * @member:	the name of the hlist_node within the struct.
 */
#define hlist_for_each_entry_continue(tpos, pos, member)		 \
	for (pos = (pos)->next;						 \
			pos && ({ prefetch(pos->next); 1;}) &&			 \
			({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
			pos = pos->next)

/**
 * hlist_for_each_entry_from - iterate over a hlist continuing from existing point
 * @tpos:	the type * to use as a loop counter.
 * @pos:	the &struct hlist_node to use as a loop counter.
 * @member:	the name of the hlist_node within the struct.
 */
#define hlist_for_each_entry_from(tpos, pos, member)			 \
	for (; pos && ({ prefetch(pos->next); 1;}) &&			 \
			({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
			pos = pos->next)

/**
 * hlist_for_each_entry_safe - iterate over list of given type safe against removal of list entry
 * @tpos:	the type * to use as a loop counter.
 * @pos:	the &struct hlist_node to use as a loop counter.
 * @n:		another &struct hlist_node to use as temporary storage
 * @head:	the head for your list.
 * @member:	the name of the hlist_node within the struct.
 */
#define hlist_for_each_entry_safe(tpos, pos, n, head, member) 		 \
	for (pos = (head)->first;					 \
			pos && ({ n = pos->next; 1; }) && 				 \
			({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
			pos = n)


#endif

在这里插入图片描述

五、抽取常用函数组成的简约版list.h —— my_list.h

// my_list.h 2023-09-24 23:07:43
#ifndef _LINUX_LIST_H
#define _LINUX_LIST_H

struct list_head {
	struct list_head *next, *prev;
};


#define INIT_LIST_HEAD(ptr) do { \
	(ptr)->next = (ptr); (ptr)->prev = (ptr); \
} while (0)

/**
 * list_empty - tests whether a list is empty
 * @head: the list to test.
 */
static inline int list_empty(const struct list_head *head)
{
	return head->next == head;
}

/*
 * Insert a new entry between two known consecutive entries.
 *
 * This is only for internal list manipulation where we know
 * the prev/next entries already!
 */
static inline void __list_add(struct list_head *new_node,
		struct list_head *prev,
		struct list_head *next)
{
	next->prev = new_node;
	new_node->next = next;
	new_node->prev = prev;
	prev->next = new_node;
}

/**
 * list_add - add a new entry
 * @new: new entry to be added
 * @head: list head to add it after
 *
 * Insert a new entry after the specified head.
 * This is good for implementing stacks.
 */
static inline void list_add(struct list_head *new_node, struct list_head *head)
{
	__list_add(new_node, head, head->next);
}

/**
 * list_add_tail - add a new entry
 * @new: new entry to be added
 * @head: list head to add it before
 *
 * Insert a new entry before the specified head.
 * This is useful for implementing queues.
 */
static inline void list_add_tail(struct list_head *new_node, struct list_head *head)
{
	__list_add(new_node, head->prev, head);
}

/*
 * Delete a list entry by making the prev/next entries
 * point to each other.
 *
 * This is only for internal list manipulation where we know
 * the prev/next entries already!
 */
static inline void __list_del(struct list_head * prev, struct list_head * next)
{
	next->prev = prev;
	prev->next = next;
}

/**
 * list_del - deletes entry from list.
 * @entry: the element to delete from the list.
 * Note: list_empty on entry does not return true after this, the entry is
 * in an undefined state.
 */
static inline void list_del(struct list_head *entry)
{
	__list_del(entry->prev, entry->next);
	//entry->next = (struct list_head *)LIST_POISON1;
	//entry->prev = (struct list_head *)LIST_POISON2;
}

#ifndef offsetof
#define offsetof(type, f) ((size_t) \
		((char *)&((type *)0)->f - (char *)(type *)0))
#endif

#ifndef container_of
#define container_of(ptr, type, member) ({ \
		const typeof( ((type *)0)->member ) *__mptr = (ptr);\
		(type *)( (char *)__mptr - offsetof(type,member) );})
#endif

/**
 * list_entry - get the struct for this entry
 * @ptr:	the &struct list_head pointer.
 * @type:	the type of the struct this is embedded in.
 * @member:	the name of the list_struct within the struct.
 */
#define list_entry(ptr, type, member) \
	container_of(ptr, type, member)

#ifndef ARCH_HAS_PREFETCH
static inline void prefetch(const void *x) {;}
#endif

/**
 * list_for_each	-	iterate over a list
 * @pos:	the &struct list_head to use as a loop counter.
 * @head:	the head for your list.
 */
#define list_for_each(pos, head) \
	for (pos = (head)->next; prefetch(pos->next), pos != (head); \
			pos = pos->next)

/**
 * list_for_each_safe	-	iterate over a list safe against removal of list entry
 * @pos:	the &struct list_head to use as a loop counter.
 * @n:		another &struct list_head to use as temporary storage
 * @head:	the head for your list.
 */
#define list_for_each_safe(pos, n, head) \
	for (pos = (head)->next, n = pos->next; pos != (head); \
			pos = n, n = pos->next)
			
/**
 * list_for_each_entry	-	iterate over list of given type
 * @pos:	the type * to use as a loop counter.
 * @head:	the head for your list.
 * @member:	the name of the list_struct within the struct.
 */
#define list_for_each_entry(pos, head, member)				\
	for (pos = list_entry((head)->next, typeof(*pos), member);	\
			prefetch(pos->member.next), &pos->member != (head); 	\
			pos = list_entry(pos->member.next, typeof(*pos), member))


#endif //_LINUX_LIST_H

在这里插入图片描述
如果文章有帮助的话，点赞👍、收藏⭐，支持一波，谢谢 😁😁😁

wkd_007
关注
  • 4
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
Linux中List.h文件的分析和应用
fengel_cs的专栏
10-07 2106
本文介绍Linux中List.h文件，此文件中用双向链表实现了多种数据结构，比如队列，堆栈等，短小精湛，值得借鉴。此文件中还有哈希表的应用。
linux——list.h
sinat_34467747的博客
09-23 6250
*linux中的头文件list.h 在Linux的源码中有一个自己为建立链表而写的链表头文件，以后可以直接调用里面的函数来使用链表。 list.h在linux中的路径为/usr/src/kernels/include/linux。不同的版本可能不一样。 list.h中有两个宏定义：#define LIST_HEAD_INIT(name) {&(name),&（name）} #define LI
c语言内核链表list.h的解释及应用_c笔记
最新发布
fudra的博客
02-01 519
一个简单的学生管理系统。
内核链表 list.h
qq_43001551的博客
10-19 200
记录一下整理的关于内核链表相关函数内容 一、双指针双向循环链表（list） 1. 基本原理 struct list_head { struct list_head* pPre; struct list_head* pNext; }; typedef struct _STU { char cSex; char szAddress[128]; int iNumber; int iFlag; struct list_head mylist; }STU;
FreeRTOS —— 关于 list.c 与 list.h 中部分内容详解
T541132的博客
04-13 248
迷你列表项就是精简的列表项，对应的结构体成员与前一个列表项结构体一样。为什么要进行 ( ListItem_t * ) ，因为根节点。，所以需要强制类型转换。
java代码-33 宋承友
07-14
11. **Java标准库**：Java附带了大量的内置类库，如JDBC（数据库连接）、Swing（图形用户界面）、JAXP（XML处理）等，宋承友的代码可能运用了其中的一些库来实现特定功能。 12. **软件工程实践**：良好的编程习惯、...
韩顺平java源码-DataStructJava:韩顺平JAVA数据结构与算法，重点是算法！
06-06
韩顺平JAVA数据结构与算法、跟着写的代码 当然，附带有测试github的作用 src文件夹才是源码 目录结构 主要目的是学习java的数据结构 重点是算法 list list下有双向链表、单向循环链表约瑟夫问题、单向链表 queue ...
icons:帮助您检查f-list.net上的图标和名称
05-24
在这个应用中，JavaScript代码会遍历网页上的每个图标元素，通过CSS选择器或者数据属性来获取相应的名称，并将其显示在用户友好的界面上。这可能包括创建一个列表或者卡片视图，每个图标旁边都附带其名称。 此外，...
Android高级编程--源代码
02-06
CruiseYoung提供的带有详细书签的电子书籍目录 http://blog.csdn.net/fksec/article/details/7888251 该资料是《Android高级编程》的源代码 对应的书籍资料见: Android高级编程 基本信息 原书名： Professional ...
Java8特性Stream流的使用（学完就会，项目源码，附带个人总结）
09-09
- `collect(Collector,A,R> collector)`：将流转换为其他数据结构，如List、Set或Map。 - `reduce(BinaryOperator<T> accumulator)`：对流的元素进行聚合操作，如求和、求最大值或最小值。 - `count()`：返回流中...
C语言头文件 LIST.H
06-12
C语言头文件 LIST.HC语言头文件 LIST.HC语言头文件 LIST.HC语言头文件 LIST.HC语言头文件 LIST.HC语言头文件 LIST.HC语言头文件 LIST.HC语言头文件 LIST.HC语言头文件 LIST.HC语言头文件 LIST.HC语言头文件 LIST.HC语言头文件 LIST.HC语言头文件 LIST.HC语言头文件 LIST.HC语言头文件 LIST.HC语言头文件 LIST.HC语言头文件 LIST.HC语言头文件 LIST.HC语言头文件 LIST.HC语言头文件 LIST.HC语言头文件 LIST.HC语言头文件 LIST.HC语言头文件 LIST.HC语言头文件 LIST.HC语言头文件 LIST.HC语言头文件 LIST.HC语言头文件 LIST.HC语言头文件 LIST.HC语言头文件 LIST.HC语言头文件 LIST.HC语言头文件 LIST.HC语言头文件 LIST.HC语言头文件 LIST.HC语言头文件 LIST.HC语言头文件 LIST.HC语言头文件 LIST.HC语言头文件 LIST.HC语言头文件 LIST.HC语言头文件
linux list.h文件,list.h头文件分析
weixin_36354355的博客
04-29 471
structlist_head{struct list_head *next, *prev;};这个就是那个链表的头！是不觉得很奇怪？怎么只有两个指针域，没有数据域呢？其实我现在也纠结这这个问题着呢！没事，咱们先往下看。说不定什么时候，咱就明白了这是怎么一回事情呢。#define LIST_HEAD_INIT(name){ &(name), &(name)}#defineLIST_...
基础数据结构——双向链表
Sauron7i的博客
08-13 250
双向链表双链表的定义程序清单Dlist.hDlist.cppmain.cpp运行结果总结 双链表的定义 为什么要有双向链表? 因为单链表有自身局限性（只能向后跑，不能向前跑），所以当我们需要向前跑的时候，就有了双向链表。 双向链表是个啥？ 和单链表相比，多了一个直接前驱指针。 示例： 单链表（假设地址为100 200 这些。。。） 双向链表 程序清单 Dlist.h 头文件中除了结构体的定义和单链表不同，其他操作基本一样。 #pragma once //结构体定义 typedef int ElemTy
c语言List头文件和应用
热门推荐
superbfly的专栏
11-29 1万+
util_list.h #ifndef __UTIL_LIST__ #define __UTIL_LIST__ /*双链节点*/ typedef struct list_node { list_node * prev; list_node * next; } LIST_NODE; /*单链节点*/ typedef struct slist_node { slist_node * ne
list.h无法打开的解决方法
m0_66022034的博客
12-06 535
list.h
Linux内核源码list.h解读
weixin_43122409的博客
09-24 3562
#list.h源码阅读 此文章是我阅读list.h后的一些见解，有问题且理解不到位的地方希望大家批评指正。 本次我们阅读的内核版本为4.18.7 在Linux内核中，list.h是内核为了方便使用链表而自己建立的链表头文件。 以__开头的是指内核函数。 ##链表 ##宏定义 除了调用其它头文件外，首先看到的是两个宏定义。 #define LIST_HEAD_INIT(name) { &amp;amp;...
可复用链表list.h
iot小胡的博客
12-02 964
这种用法惊艳到我了!!! 传统的教科书式的链表有个非常大的缺点: 一句话讲就是 复用性差 每种类型的链表我们都需要编写不同的函数去实现增删改查等基本操作 不仅效率低, 而且还容易出错 而 linux内核 的 list.h 就是为了解决这一痛点而诞生的 我们只需要添加基本的成员, 然后对 list.h 中的函数简单封装一下, 就能够实现想要的功能了 须知 我们使用的 list 是一种特殊双向环形链表, 双向环形链表 大家可能比较好理解, 那么特...
list.h 简单运用
u012566181的专栏
09-02 1357
#include #include #include "list.h" struct kool_list {     struct list_head list;     int to,from; }; //这个定义把list_head结构放在第一位很有讲究，因为后面 //可以直接利用list_for_each宏来直接得到koo_list的位置，因为 //每个koo
Linux中链表（list.h）的实现原理
wzf1993的博客
10-08 704
原文地址：http://wuzufei.cn/linux_list.html 1 概述 通常情况下，我们使用C语言实现定义的链表节点形式如下： struct Node { int data; struct Node* next; }; 常规使用一个结构体定义节点，然后在每个节点中保存前驱/后继节点的首地址，通过遍历每个节点中的next成员访问下一个节点； 而在linux 的内核实现中，链表节点定义方式如下： struct list_head { struct
linux list.h
09-12
list.h是Linux内核中的一个头文件，定义了一个双向链表的数据结构和相关操作函数。该头文件为许多Linux内核的子系统和驱动程序提供了链表数据结构的基本操作方法，比如文件系统、网络、USB、设备驱动程序等。 list.h中最重要的部分是双向链表的数据结构定义。双向链表是一种由节点组成的数据结构，每个节点包含了一个数据元素和两个指针，一个指向下一个节点，一个指向上一个节点。这种数据结构的特点是可以在任何位置高效地插入和删除元素，同时能够在节点间快速地移动。 在list.h中，链表节点定义为"struct list_head"类型，每个节点包含next和prev两个指针。同时，链表头定义为"struct list_head"类型的指针，代表链表首节点。通过这种定义，可以构造复杂的链表数据结构。 list.h中的操作函数包括初始化链表、插入和删除节点、判断链表是否为空、获取链表长度等。这些操作函数既可以通过直接调用，也可以通过一些宏来使用。这些函数和宏提供了一种高效的方式来操作链表，使得编写内核代码更加方便和简洁。 总之，list.h是Linux内核中为许多子系统和驱动程序提供链表数据结构和操作函数的头文件。通过使用该头文件提供的链表操作方法，可以在Linux内核中高效地处理链表数据，使得内核代码更加灵活和可维护。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

wkd_007

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值