linux内核链表

最新推荐文章于 2024-07-07 15:59:47 发布
最新推荐文章于 2024-07-07 15:59:47 发布
阅读量112 收藏
点赞数
分类专栏： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_28691955/article/details/116754425
版权 
/*********************************************************************************************
    *  @Copyright (c) , All rights reserved.
    *  @file:       ListHead.hpp
    *  @version:    ver 1.0
    *  @author:     闹闹
    *  @brief:  
    *  @change:
    *  @email: 	1319144981@qq.com
    *  Date             Version    Changed By      Changes 
    *  2021/5/10 9:49:00    1.0       闹闹            create
	写一句自己最喜欢的话吧。
	为天地立心，为生民立命，为往圣继绝学，为万世开太平。
**********************************************************************************************/
/**********************************************************************************************
* modify_author:			闹闹
* modify_time:      2021/5/10 13:05:53
* modify_content:	
* modify_reference:
* modify_other:
参考链接：  https://blog.csdn.net/dijkstar/article/details/19249219
			https://blog.csdn.net/weixin_40746176/article/details/100530190
			https://blog.csdn.net/u014453898/article/details/53741921
			https://blog.csdn.net/szullc/article/details/86565368
使用方法：	https://blog.csdn.net/wanshilun/article/details/79747710
* modify_version:   1.0.0.2
**********************************************************************************************/
#pragma once
#ifndef __LISTHEAD_H__
#define __LISTHEAD_H__
#define LIST_POISON1  ((void *) 0x00100100)
#define LIST_POISON2  ((void *) 0x00200200)
#ifndef ARCH_HAS_PREFETCH
#define ARCH_HAS_PREFETCH
static inline void prefetch(const void *x) { ; }
static inline void prefetchw(const void *x) { ; }
#endif
/******************************************************************************
* @FuncName:
* @Author:    闹闹
* @Brief:    定义一个结构体，只含有表示前驱和后继的指针，它就是我们的主角了
* @Version:   1.0.0.1
* @Date:	  2021/5/10 9:56
* @InputParameter:
* @OutputParameter:
* @Returns:
* @Others:
******************************************************************************/
struct list_head {
	struct list_head *next, *prev;
};
/******************************************************************************
* @FuncName:  
* @Author:    闹闹
* @Brief:     静态初始化
* @Version:   1.0.0.1
* @Date:	  2021/5/10 9:56
* @InputParameter: 
* @OutputParameter: 
* @Returns:   
* @Others:    
******************************************************************************/
#define LIST_HEAD_INIT(name){&(name),&(name)}
#define LIST_HEAD(name) \
    struct list_head name = LIST_HEAD_INIT(name)

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

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

/******************************************************************************
* @FuncName:
* @Author:    闹闹
* @Brief:    将一个元素插入到两个元素之间, 即将 new插入到prev和next中, 这个函数是下面在头部和尾部插入的实现基础
* @Version:   1.0.0.1
* @Date:	  2021/5/10 9:56
* @InputParameter:
* @OutputParameter:
* @Returns:
* @Others:
******************************************************************************/
static inline void __list_add(struct list_head *newptr,struct list_head *prev,struct list_head *next){
	// 前后向指针的改写赋值
	next->prev = newptr;
	newptr->next = next;
	newptr->prev = prev;
	prev->next = newptr;
}

/******************************************************************************
* @FuncName:
* @Author:    闹闹
* @Brief:     在头部插入,在头指针和第一个元素间插入,
* @Version:   1.0.0.1
* @Date:	  2021/5/10 9:56
* @InputParameter: newptr  新指针  head 链表头指针
* @OutputParameter:
* @Returns:
* @Others:
******************************************************************************/
static inline void list_add(struct list_head *newptr, struct list_head *head){
	__list_add(newptr, head, head->next);
}

/******************************************************************************
* @FuncName:
* @Author:    闹闹
* @Brief:    在尾部插入,在最后一个元素间和头指针间插入, 因为是循环链表嘛~
* @Version:   1.0.0.1
* @Date:	  2021/5/10 9:56
* @InputParameter: newptr  新指针  head 链表头指针
* @OutputParameter:
* @Returns:
* @Others:
******************************************************************************/
static inline void list_add_tail(struct list_head *newptr, struct list_head *head){
	__list_add(newptr, head->prev, head);
}

/******************************************************************************
* @FuncName:
* @Author:    闹闹
* @Brief:    删除两个元素之间的元素~
* @Version:   1.0.0.1
* @Date:	  2021/5/10 9:56
* @InputParameter:
* @OutputParameter:
* @Returns:
* @Others:
******************************************************************************/
static inline void __list_del(struct list_head * prev, struct list_head * next){
	next->prev = prev;
	prev->next = next;
}

/******************************************************************************
* @FuncName:
* @Author:    闹闹
* @Brief:    删除一个已知元素entry
* @Version:   1.0.0.1
* @Date:	  2021/5/10 9:56
* @InputParameter:
* @OutputParameter:
* @Returns:
* @Others:
******************************************************************************/
static inline void list_del(struct list_head *entry){
	__list_del(entry->prev, entry->next);
	entry->next = (list_head *)LIST_POISON1;
	entry->prev = (list_head *)LIST_POISON2;
}

static inline void list_del_init(struct list_head *entry){
	__list_del(entry->prev, entry->next);
	INIT_LIST_HEAD(entry);
}

/******************************************************************************
* @FuncName:
* @Author:    闹闹
* @Brief:    指针的变换
* @Version:   1.0.0.1
* @Date:	  2021/5/10 9:56
* @InputParameter:
* @OutputParameter:
* @Returns:
* @Others:
******************************************************************************/
static inline void list_replace(struct list_head *old,struct list_head *newptr){
	newptr->next = old->next;
	newptr->next->prev = newptr;
	newptr->prev = old->prev;
	newptr->prev->next = newptr;
}

static inline void list_replace_init(struct list_head *old,struct list_head *newptr){
	list_replace(old, newptr);
	INIT_LIST_HEAD(old);
}

/******************************************************************************
* @FuncName:
* @Author:    闹闹
* @Brief:    将一个元素list 移动到另一个链表的head的头部
* @Version:   1.0.0.1
* @Date:	  2021/5/10 9:56
* @InputParameter:
* @OutputParameter:
* @Returns:
* @Others:
******************************************************************************/
static inline void list_move(struct list_head *list, struct list_head *head){
	// 从原处的list后摘掉
	__list_del(list->prev,list->next);
	// 添加到新链表的头部
	list_add(list, head);
}

/******************************************************************************
* @FuncName:
* @Author:    闹闹
* @Brief:    将一个元素list 移动到另一个链表head的队尾
* @Version:   1.0.0.1
* @Date:	  2021/5/10 9:56
* @InputParameter:
* @OutputParameter:
* @Returns:
* @Others:
******************************************************************************/
static inline void list_move_tail(struct list_head *list,struct list_head *head){
	// 从原处的list后摘掉
	__list_del(list->prev,list->next);
	// 添加到新链表的队尾
	list_add_tail(list, head);
}

/******************************************************************************
* @FuncName:
* @Author:    闹闹
* @Brief:    链表是否为空
* @Version:   1.0.0.1
* @Date:	  2021/5/10 9:56
* @InputParameter:
* @OutputParameter:
* @Returns:
* @Others:
******************************************************************************/
static inline int list_empty(struct list_head *head){
	return head->next == head;
}

/******************************************************************************
* @FuncName:
* @Author:    闹闹
* @Brief:    list 是否为最后一个元素
* @Version:   1.0.0.1
* @Date:	  2021/5/10 9:56
* @InputParameter:
* @OutputParameter:
* @Returns:
* @Others:
******************************************************************************/
static inline int list_is_last(const struct list_head *list, const struct list_head *head){
	return list->next == head;
}

/******************************************************************************
* @FuncName:
* @Author:    闹闹
* @Brief:    检查链表是否为空并且没有被改变
* @Version:   1.0.0.1
* @Date:	  2021/5/10 9:56
* @InputParameter:
* @OutputParameter:
* @Returns:
* @Others:
******************************************************************************/
static inline int list_empty_careful(const struct list_head *head){
	struct list_head *next = head->next;
	return (next == head) && (next == head->prev);
}

/******************************************************************************
* @FuncName:
* @Author:    闹闹
* @Brief:    拆分操作, 将一个队列由指定的位置拆成两个队列
* @Version:   1.0.0.1
* @Date:	  2021/5/10 9:56
* @InputParameter:
* @OutputParameter:
* @Returns:
* @Others: list是新队列的head指针, 包括的元素从原head队列的第一个元素到entry, head队列仅包括余下的元素
******************************************************************************/
static inline void __list_cut_position(struct list_head *list,struct list_head *head, struct list_head *entry){
	struct list_head *new_first = entry->next;
	list->next = head->next;
	list->next->prev = list;
	list->prev = entry;
	entry->next = list;
	head->next = new_first;
	new_first->prev = head;
}

/******************************************************************************
* @FuncName:
* @Author:    闹闹
* @Brief:    将list列表中除了list当前节点本身的其余部分，插入到prev和next之间
* @Version:   1.0.0.1
* @Date:	  2021/5/10 9:56
* @InputParameter:
* @OutputParameter:
* @Returns:
* @Others: 
******************************************************************************/
static inline void __list_splice(const struct list_head *list,struct list_head *prev){
	struct list_head *first = list->next;
	struct list_head *last = list->prev;
	struct list_head *at = prev->next;

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

	last->next = at;
	at->prev = last;
}
/******************************************************************************
* @FuncName:
* @Author:    闹闹
* @Brief:    将一个列表插入到另一个列表的头部
* @Version:   1.0.0.1
* @Date:	  2021/5/10 9:56
* @InputParameter:
* @OutputParameter:
* @Returns:
* @Others:
******************************************************************************/
static inline void list_splice(struct list_head *list,struct list_head *head){
	if (!list_empty(list))
		__list_splice(list, head);
}

/******************************************************************************
* @FuncName:
* @Author:    闹闹
* @Brief:   连接两个列表并重新初始化清空的列表。
* @Version:   1.0.0.1
* @Date:	  2021/5/10 9:56
* @InputParameter:
* @OutputParameter:
* @Returns:
* @Others:
******************************************************************************/
static  void list_splice_init(struct list_head *list,struct list_head *head){
	if (!list_empty(list)) {
		__list_splice(list, head);
		INIT_LIST_HEAD(list);
	}
}

/******************************************************************************
* @FuncName:
* @Author:    闹闹
* @Brief:    将一个列表插入到另一个列表的尾部
* @Version:   1.0.0.1
* @Date:	  2021/5/10 9:56
* @InputParameter:
* @OutputParameter:
* @Returns:
* @Others:
******************************************************************************/
static inline void list_splice_tail(struct list_head *list,struct list_head *head){
	if (!list_empty(list))
		__list_splice(list, head->prev);
}

/******************************************************************************
* @FuncName:
* @Author:    闹闹
* @Brief:    得到链表中的对象
* @Version:   1.0.0.1
* @Date:	  2021/5/10 9:56
* @InputParameter:
* @OutputParameter:
* @Returns:
* @Others:
******************************************************************************/
#define list_entry(ptr, type, member) \
   ((type *)((char *)(ptr)-(size_t)(&((type *)0)->member)))



/******************************************************************************
* @FuncName:
* @Author:    闹闹
* @Brief:   得到链表第一个元素
* @Version:   1.0.0.1
* @Date:	  2021/5/10 9:56
* @InputParameter:
* @OutputParameter:
* @Returns:
* @Others:
* list_first_entry - get the first element from a list
* @ptr:    the list head to take the element from.
* @type:   the type of the struct this is embedded in.
* @member: the name of the list_struct within the struct.
*
* Note, that list is expected to be not empty.
******************************************************************************/
#define list_first_entry(ptr, type, member) \
    list_entry((ptr)->next, type, member)


/******************************************************************************
* @FuncName:
* @Author:    闹闹
* @Brief:    链表遍历，从前向后
* @Version:   1.0.0.1
* @Date:	  2021/5/10 9:56
* @InputParameter:
* @OutputParameter:
* @Returns:
* @Others:
* 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, prefetch(pos->next))

/******************************************************************************
* @FuncName:
* @Author:    闹闹
* @Brief:    链表遍历，从前向后
* @Version:   1.0.0.1
* @Date:	  2021/5/10 9:56
* @InputParameter:
* @OutputParameter:
* @Returns:
* @Others:
* __list_for_each  -   iterate over a list
* @pos:    the &struct list_head to use as a loop cursor.
* @head:   the head for your list.
*
此变体与list_for_each（）的不同之处在于它是最简单的列表迭代代码，不需要预取。对于知道列表非常短（空）的代码，使用此选项比上式减少很多时间。
******************************************************************************/
#define __list_for_each(pos, head) \
    for (pos = (head)->next; pos != (head); pos = pos->next)

/******************************************************************************
* @FuncName:
* @Author:    闹闹
* @Brief:    链表遍历，从后向前
* @Version:   1.0.0.1
* @Date:	  2021/5/10 9:56
* @InputParameter:
* @OutputParameter:
* @Returns:
* @Others:
* 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, prefetch(pos->prev))

/******************************************************************************
* @FuncName:
* @Author:    闹闹
* @Brief:    链表遍历，从后向前，对列表进行迭代，以防向后删除列表项
* @Version:   1.0.0.1
* @Date:	  2021/5/10 9:56
* @InputParameter:
* @OutputParameter:
* @Returns:
* @Others:
* list_for_each_prev_safe   -   iterate over a list safe against removal of list entry backwards
* @pos:    the &struct list_head to use as a loop cursor.
* @n:      another &struct list_head to use as temporary storage
* @head:   the head for your list.
******************************************************************************/
#define list_for_each_prev_safe(pos, n, head) \
    for (pos = (head)->prev, n = pos->prev; prefetch(pos->prev), pos != (head); \
            pos =n, n = pos->prev)

/******************************************************************************
* @FuncName:
* @Author:    闹闹
* @Brief:    链表遍历，从前向后，对列表进行迭代以防止删除列表项
* @Version:   1.0.0.1
* @Date:	  2021/5/10 9:56
* @InputParameter:
* @OutputParameter:
* @Returns:
* @Others:
* 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)

/******************************************************************************
* @FuncName:
* @Author:    闹闹
* @Brief:    链表遍历，从前向后，迭代给定类型的列表
* @Version:   1.0.0.1
* @Date:	  2021/5/10 9:56
* @InputParameter:
* @OutputParameter:
* @Returns:
* @Others:
* 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))

/******************************************************************************
* @FuncName:
* @Author:    闹闹
* @Brief:    链表遍历，从后向前，迭代给定类型的列表
* @Version:   1.0.0.1
* @Date:	  2021/5/10 9:56
* @InputParameter:
* @OutputParameter:
* @Returns:
* @Others:
* list_for_each_entry_reverse - iterate backwards over list of given type.
* @pos:    the type * to use as a loop cursor.
* @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))


/******************************************************************************
* @FuncName:
* @Author:    闹闹
* @Brief:    为每个项目准备一个pos条目，以便在列表中使用list_for_each_entry_continue()
* @Version:   1.0.0.1
* @Date:	  2021/5/10 9:56
* @InputParameter:
* @OutputParameter:
* @Returns:
* @Others:
* list_prepare_entry - prepare a pos entry for use 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.
*
* Prepares a pos entry for use as a start point in list_for_each_entry_continue().
******************************************************************************/
#define list_prepare_entry(pos, head, member) \
            ((pos) ? : list_entry(head, typeof(*pos), member))


/******************************************************************************
* @FuncName:
* @Author:    闹闹
* @Brief:    继续迭代给定类型列表
* @Version:   1.0.0.1
* @Date:	  2021/5/10 9:56
* @InputParameter:
* @OutputParameter:
* @Returns:
* @Others:
* list_for_each_entry_continue - continue iteration over list of given type
* @pos:    the type * to use as a loop cursor.
* @head:   the head for your list.
* @member: the name of the list_struct within the struct.
*
* Continue to iterate over list of given type, continuing after
* the current position.
******************************************************************************/
#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))

/******************************************************************************
* @FuncName:
* @Author:    闹闹
* @Brief:   从当前点迭代给定类型的列表
* @Version:   1.0.0.1
* @Date:	  2021/5/10 9:56
* @InputParameter:
* @OutputParameter:
* @Returns:
* @Others:
* list_for_each_entry_from - iterate over list of given type from the current point
* @pos:    the type * to use as a loop cursor.
* @head:   the head for your list.
* @member: the name of the list_struct within the struct.
*
* Iterate over list of given type, continuing from current position.
******************************************************************************/
#define list_for_each_entry_from(pos, head, member)             \
            for (; prefetch(pos->member.next), &pos->member != (head);  \
                 pos = list_entry(pos->member.next, typeof(*pos), member))

/******************************************************************************
* @FuncName:
* @Author:    闹闹
* @Brief:   从当前点迭代给定类型的列表，迭代给定类型的列表，以防止删除列表项
* @Version:   1.0.0.1
* @Date:	  2021/5/10 9:56
* @InputParameter:
* @OutputParameter:
* @Returns:
* @Others:
* 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))

/******************************************************************************
* @FuncName:
* @Author:    闹闹
* @Brief:   迭代给定类型的列表，在当前点之后继续，防止删除列表条目。
* @Version:   1.0.0.1
* @Date:	  2021/5/10 9:56
* @InputParameter:
* @OutputParameter:
* @Returns:
* @Others:
* list_for_each_entry_safe_continue
* @pos:    the type * to use as a loop cursor.
* @n:      another type * to use as temporary storage
* @head:   the head for your list.
* @member: the name of the list_struct within the struct.
* Iterate over list of given type, continuing after current point,
* safe against removal of list entry.
******************************************************************************/
#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))


/******************************************************************************
* @FuncName:
* @Author:    闹闹
* @Brief:  从当前点遍历给定类型的列表删除列表条目。
* @Version:   1.0.0.1
* @Date:	  2021/5/10 9:56
* @InputParameter:
* @OutputParameter:
* @Returns:
* @Others:
* list_for_each_entry_safe_from
* @pos:    the type * to use as a loop cursor.
* @n:      another type * to use as temporary storage
* @head:   the head for your list.
* @member: the name of the list_struct within the struct.
*
* Iterate over list of given type from current point, safe against
* removal of list entry.
******************************************************************************/
#define list_for_each_entry_safe_from(pos, n, head, member)             \
                    for (n = list_entry(pos->member.next, typeof(*pos), member);        \
                         &pos->member != (head);                        \
                         pos = n, n = list_entry(n->member.next, typeof(*n), member))

/******************************************************************************
* @FuncName:
* @Author:    闹闹
* @Brief:  向后迭代给定类型的列表，防止删除列表条目的数目。
* @Version:   1.0.0.1
* @Date:	  2021/5/10 9:56
* @InputParameter:
* @OutputParameter:
* @Returns:
* @Others:
* list_for_each_entry_safe_reverse
* @pos:    the type * to use as a loop cursor.
* @n:      another type * to use as temporary storage
* @head:   the head for your list.
* @member: the name of the list_struct within the struct.
*
* Iterate backwards over list of given type, safe against removal
* of list entry.
******************************************************************************/
#define list_for_each_entry_safe_reverse(pos, n, head, member)      \
                        for (pos = list_entry((head)->prev, typeof(*pos), member),  \
                            n = list_entry(pos->member.prev, typeof(*pos), member); \
                             &pos->member != (head);                    \
                             pos = n, n = list_entry(n->member.prev, typeof(*n), member))

#endif  //__LISTHEAD_H__
/************************ (C) COPYRIGHT LEI *****END OF FILE****/

example

#include "stdio.h"
#include <stdlib.h>
#include <string.h>
#include "ListHead.hpp"

//自定义的数据结构
struct list_test_struct
{
	struct list_head	list;

	int key;
	int data;
};

void main()
{
	struct list_head list = { 0 };  //定义链表（头） 
	struct list_head *pos = NULL;
	struct list_head *n = NULL;

	int i = 0;

	printf("定义链表\n");

	printf("初始化链表！\r\n");
	INIT_LIST_HEAD(&list);  //初始化链表（头尾相接，形成空链表循环） 

							//判断链表是否为空 
	printf("判断链表是否为空：");
	if (list_empty(&list)) {
		printf("空\r\n");
	}
	else {
		printf("非空\r\n");
	}

	//批量添加节点 
	printf("批量添加节点：\r\n");
	for (i = 0; i < 10; i++)
	{
		int key = i;    //key 
		int data = i * 10;  //data 

		struct list_test_struct *st = (struct list_test_struct*)malloc(sizeof(struct list_test_struct));
		st->key = key;
		st->data = data;
		list_add(&st->list, &list);
	}

	//显示列表所有节点 
	printf("显示列表所有节点：\r\n");
	list_for_each(pos, &list)
	{
		struct list_test_struct *st = list_entry(pos, struct list_test_struct, list);
		printf("\t node:key(%d),data(%d)\r\n", st->key, st->data);
	}

	//释放所有节点资源 
	printf("释放所有节点资源！\r\n");
	list_for_each_safe(pos, n, &list)
	{
		struct list_test_struct *st = list_entry(pos, struct list_test_struct, list);
		list_del(pos);  //删除节点，删除节点必须在删除节点内存之前 
		free(st);   //释放节点内存 
	}

	system("psuse");

}
__2得很别致
关注
专栏目录
Linux内核链表
健身房
07-25 173
  linux内核链表不是在链表节点中包含数据，而是在数据结构中包含链表节点。其在linux内核中的定义为： struct autofs { char *name; int len; struct list_head list; } 使用示例如下： #include <linux/kernel.h> #include <linux/module.h> #include <linux/init.h> #include "linux/fs.h" #i
linux内核中的链表
weixin_30763397的博客
06-03 333
1.内核中的链表 linux内核链表与众不同，他不是把将数据结构塞入链表，而是将链表节点塞入数据，在2.1内核中引入了官方链表，从此内核中所有的链表使用都采用此链表，千万不要在重复造车轮子了！链表实现定义在<linux/list.h>,使用内核链表时，包含此文件。 1.1.传统的双向链表和内核中的双向链表的区别 有个单独的头结点(head) 每个节点(node)除了包含必要的数据之外...
LINUX内核链表
Jaylen.sun的嵌入式之旅
02-15 863
Linux 内核链表的思路把传统链表中的“链”抽象出来，使之成为一条只包含前后指针的纯粹的双循环链表，这样的链表由于不含有特殊的数据，因此它实质上就是链表的抽象表示，类似于一条通用的绳子，在实际应用中只需将这条绳子“嵌入”一个具体的节点当中
Linux 内核链表
chi's blog
08-18 190
在Linux内核中使用了大量的链表结构来组织数据，包括设备列表以及各种功能模块中的数据组织。这些链表大多采用在[include/linux/list.h]实现的一个相当精彩的链表数据结构。事实上，内核链表就是采用双循环链表机制。内核链表有别于传统链表就在节点本身不包含数据域，只包含指针域。故而可以很灵活的拓展数据结构。而这种方式组成的链表又被称为是侵入式链表，具体可以参考这篇文章，这里就不作过多赘述了。侵入式链表，内核链表。
Linux内核链表使用方法
最新发布
hinewcc的博客
07-07 1275
Linux内核链表使用方法介绍
Linux内核链表移植和测试代码
10-15
本知识点将深入探讨Linux内核链表的移植和测试，以及`list.c`和`list.h`这两个文件的作用。 Linux内核中的链表API主要集中在`<linux/list.h>`头文件中，但在提供的`list.h`文件中，我们可以推测它是对原生内核链表...
linux内核链表提取与使用
12-21
将linux内核源码中list.h拿出来, 增删与遍历部分写了详细注释, 关于链表合并, 没用过所以没写. 源码版本是2.6.32, 不过链表的源码改动应该不是很大. 我的邮箱2253238252@qq.com, 代码有什么不对的欢迎发邮件给我
抽取linux内核链表模块
08-06
标题中的"抽取linux内核链表模块"涉及到的是从Linux内核源码中提取出链表（list）的实现，以便在用户空间的Linux应用程序中复用这些功能。这一过程有助于理解链表的内部工作原理，并能在自己的代码中有效地利用内核...
linux内核链表测试用例
05-31
这个“linux内核链表测试用例”是一个演示如何在实际编程中应用这些链表的实例。下面我们将深入探讨Linux内核链表的基本概念、结构、操作以及测试用例的重要性。 **Linux内核链表基本概念** Linux内核链表（list_...
linux内核链表实现
12-28
linux内核链表的实现，包括内核链表的定义，以及内核链表相关的操作
spdlog使用示例
__2得很别致
06-05 5074
// // Copyright(c) 2015 Gabi Melman. // Distributed under the MIT License (http://opensource.org/licenses/MIT) // spdlog usage example /* 参考文献 https://blog.csdn.net/haojie_superstar/article/details/89383433?ops_request_misc=&request_id=&biz_id=102
Fmt的安装与使用，最主要是吐槽。
__2得很别致
08-21 4276
安装 本文的编译平台的是VS2015 与Cmake. 1、打开Cmake，在1处选择下载的源码， 2、在2处选择生成文件所放在的位置。需要自己在目录下新建build文件夹。 3、点击3处生成配置。注意第一次点击的时候会出现一个对话框，让你选择编译平台。我选的是VS2015 X64平台。默认不选的话会是x86的。 4、第一次点击3处按钮可能会出现红色的，如图所示。再点击一次3处按钮。 5、点击4处按钮，在build文件夹生成项目文件。 6、点击下面的fmt项目，右键重新生成，生成库文件，注意是releas
c++ 判断成员变量和函数是否存在
__2得很别致
11-03 1987
这个自己查的资料，好多都是直接讲理论，说到代码就唧唧了。自己尝试写了一哈，在vs2015下测试通过。 example_1.cpp #include <iostream> #include <type_traits> using namespace std; /* 解决了检查成员函数是否存在的问题， 参考链接 https://www.csdn.net/article/2015-12-03/2826381 */ #define HAS_MEMBER(member)\ tem.
c++：根据文件名在目录下找文件，返回全路径
__2得很别致
06-01 1279
//头文件是从项目文件拷贝来的，看不需要的自己删除（多字节环境） #include <vector> #include <list> #include <string> #include <fstream> #include <io.h> #include <direct.h> #include <string> #include <iostream> //根据文件名搜索目录下的文件 void GetForma
c++ 时间轮与时间堆定时器
__2得很别致
11-03 1071
相应的参考链接与注释都在代码里面，不懂的可以直接点开链接查看。 注释：时间轮定时器是指定时间间隔和一轮的总时间进行定时，时间堆定时器是指定执行次数和时间间隔进行定时(不要删除定时器)。 时间轮定时器 TimeWheel.h #pragma once #ifndef __TIMEWHEEL_H__ #define __TIMEWHEEL_H__ /* 参考链接 https://cloud.tencent.com/developer/article/1361827 https://www.cnblogs..
regex主要规则与学习笔记
__2得很别致
08-31 749
参考链接 https://github.com/ziishaned/learn-regex # 正则表达式 # https://github.com/ziishaned/learn-regex/blob/master/translations/README-cn.md 元字符 . 句号匹配任意单个字符除了换行符。 [ ] 字符种类。匹配方括号内的任意字符。 [^ ] 否定的字符种类。匹配除了方括号里的任意字符 * 匹配>=0个重复的在*号之前的字符。 + 匹配&g
c++开源项目：从零开始的 JSON 库教程
__2得很别致
08-31 665
参考链接 https://github.com/miloyip/json-tutorial 本文主要是代码，要看讲解的话，见参考链接。 说明：本文主要是学习库文件的编写规则与规范，宏函数写法，与测试驱动开发的过程。 leptjson.h #ifndef LEPTJSON_H__ #define LEPTJSON_H__ #include <stddef.h> /* size_t */ typedef enum { LEPT_NULL, LEPT_FALSE, LEPT_TRUE, LEPT_
c++ windows锁
__2得很别致
11-03 666
单位内部人员写的，可以借鉴与使用。 windows平台 lock.h #ifndef Lock_H_ #define Lock_H_ #include <windows.h> //锁接口类 class IMyLock { public: virtual ~IMyLock() {} virtual void Lock(){}; virtual void Unlock(){}; }; //互斥对象锁类 class CMutexLock : public IMyLock { pu.
c++ xml的读写(tinyxml2)
__2得很别致
08-31 344
参考链接 https://www.cnblogs.com/kex1n/archive/2010/10/03/1841502.html https://blog.csdn.net/bjwzhscs/article/details/36873707 https://www.cnblogs.com/cy568searchx/p/3670400.html 本文使用的是tinyxml2库 #include "tinyxml2/tinyxml2.h" #include <iostream> #incl
linux 内核链表
10-15
Linux 内核链表是 Linux 内核中常用的一种数据结构，它是由多个节点组成的链式结构，每个节点包含了指向前一个节点和后一个节点的指针。Linux 内核链表的实现是通过定义一个 struct list_head 结构体来实现的，这个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值