一、简介概述
1、普通链表数据结构
每个节点的next指针指向下一个节点的首地址。这样会有如下的限制：
- 一条链表上的所有节点的数据类型需要完全一致。
- 对某条链表的操作如插入，删除等只能对这种类型的链表进行操作，如果链表的类型换了，就要重新再封装出一套一样的操作，泛化能力差
2、侵入式链表数据结构
节点的链接成员指向的是下一个节点的链接成员。使用侵入式链表的好处是：
- 节点类型无需一致，只需要成员节点（element_t）包含list_node_t成员即可
- 泛化能力强，所有链表的操作方式均可统一；
typedef struct list_node list_node_t;
//链表节点结构体定义
typedef struct list_node {
list_node_t* prev;
list_node_t* next;
} list_node_t;
//链表结构体定义
typedef struct list {
int list_size;
list_node_t head;
} list_t;
//链表成员结构体定义，重点需要包含list_node_t定义
typedef struct element {
list_node_t list_node;
int element_type;
int element_size;
char element_data[1];
} element_t;二、详细介绍
侵入式链表中的节点只有地址信息，能够访问节点上的数据成员变量，主要靠两个核心函数：
- offsetof
- container_of
1、offsetof
1）宏原型
#if defined _MSC_VER && !defined _CRT_USE_BUILTIN_OFFSETOF
#ifdef __cplusplus
#define offsetof(s,m) \
((::size_t)&reinterpret_cast<char const volatile&>((((s*)0)->m)))
#else
#define offsetof(s,m) ((size_t)&(((s*)0)->m))
#endif
#else
#define offsetof(s,m) __builtin_offsetof(s,m)
#endif2）宏作用
计算结构体成员相对于结构体的偏移
3）参数说明
- type： 结构体类型
- member：结构体成员
4）原理分析
偏移 = 成员地址 - 结构体地址，若结构体地址为0，则偏移 = 成员地址；
5）应用示例
typedef struct element {
list_node_t list_node;
int element_type;
int element_size;
char element_data[1];
} element_t;
printf("offset: %zd %zd %zd\r\n",
offsetof(element_t, list_node),
offsetof(element_t, element_type),
offsetof(element_t, element_size));
//打印结果
offset: 0 16 202、container_of
1）宏原型
#define container_of(ptr, type, member) \
((type*)(((char*)((type*)(ptr))) - offsetof(type, member)))2）宏作用
通过结构体的成员，结构体成员的地址以及结构体的类型来获取结构体的首地址。
3）参数说明
- ptr： 结构体成员的地址
- type： 结构体类型
- member：结构体成员
4）原理分析
结构体首地址 = 成员地址 - 成员偏移，成员偏移通过offsetof宏求出；
5）应用示例
int main()
{
element_t element, *p_element;
element.element_type = 1234;
element.element_size = 5678;
p_element = container_of(&element.list_node, element_t, list_node);
printf("p_element->element_type :%d p_element->element_size :%d\n",
p_element->element_type, p_element->element_size);
}
p_element->element_type :1234 p_element->element_size :56783、侵入式链表
介绍到这里，就可以理解面前第一章第2小节，介绍的节点类型无需一致，只需要成员节点（element_t）包含list_node_t成员即可。我们只要知道list_node_t成员地址，就可以通过offsetof=>container_of获取整个element_t的成员变量。
示例代码如下：
#include "list.h"
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
void ListInit(list_t* list) {
list->list_size = 0;
ListNodeInit(&list->head);
}
void ListAppend(list_t* list, list_node_t* node) {
node->next = &list->head;
node->prev = list->head.prev;
node->prev->next = node;
list->head.prev = node;
list->list_size++;
}
void ListRemove(list_t* list, list_node_t* node) {
ListNodeDetach(node);
ListNodeInit(node);
list->list_size--;
}
list_node_t* ListFirstGet(const list_t* list) {
return !ListEmpty(list) ? list->head.next : NULL;
}
list_node_t* ListLastGet(const list_t* list) {
return !ListEmpty(list) ? list->head.prev : NULL;
}
bool ListEmpty(const list_t* list) {
return !ListEnlisted(&list->head);
}
void ListNodeInit(list_node_t* node) {
node->prev = node;
node->next = node;
}
void ListNodeDetach(list_node_t* node) {
node->prev->next = node->next;
node->next->prev = node->prev;
}
bool ListEnlisted(const list_node_t* node) {
return node->prev != node;
}
list_t list_;
int main()
{
list_node_t* list_node = NULL;
ListInit(&list_);
for (int i = 0; i < 15; i++) {
element_t* element = (element_t*)malloc(sizeof(element_t) + sizeof(AI_UPLOAD_ALL_INFO_T));
element->element_type = i;
element->element_size = sizeof(AI_UPLOAD_ALL_INFO_T);
ListAppend(&list_, &element->list_node);
printf("push element :%d queue_size :%d\n", element->element_type, list_.list_size);
list_node = ListLastGet(&list_);
element_t* element1 = GetListNode(list_node, element_t);
printf("QueueLastGet element :%d queue_size :%d\n", element1->element_type, list_.list_size);
}
printf("list_size :%d\n", list_.list_size);
while ((list_node = ListFirstGet(&list_)) != NULL) {
element_t* element = GetListNode(list_node, element_t);
printf("pop element :%d queue_size :%d\n", element->element_type, list_.list_size);
ListRemove(&list_, list_node);
}
return 0;
}
