你好!这里是风筝的博客,
欢迎和我一起多多交流。
看了下Linux链表的实现,发现真的是把“驱动和设备分离”的思想发挥的淋漓尽致啊!
之前我写链表是这么写的:
Linux下链表是这样:
这两者有什么不同呢?
当然,我不是想说双向链表的事,而是指针域与数据域分离的事情。
把链表的底层实现封装起来进行屏蔽,只留出数据域。这样,当链表有改动时,只需修改数据域即可,底层链表实现不需要改动。
Linux中的list.h文件:
#ifndef LIST_H
#define LIST_H
#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
/**
* container_of - cast a member of a structure out to the containing structure
* @ptr: the pointer to the member.
* @type: the type of the container struct this is embedded in.
* @member: the name of the member within the struct.
*
*/
#define container_of(ptr, type, member) ({ \
const typeof( ((type *)0)->member ) *__mptr = (ptr); \
(type *)( (char *)__mptr - offsetof(type,member) );})
/*指针域节点*/
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)
/*节点初始化*/
static inline void INIT_LIST_HEAD(struct list_head *list)
{
list->next = list;
list->prev = list;
}
/**
* 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_head within the struct.
*/
#define list_entry(ptr, type, member) \
container_of(ptr, type, member)
/**
* list_for_each_entry - iterate 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_head within the struct.
*/
/*遍历链表*/
#define list_for_each_entry(pos, head, member) \
for (pos = list_entry((head)->next, typeof(*pos), member); \
&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 cursor.
* @n: another type * to use as temporary storage
* @head: the head for your list.
* @member: the name of the list_head 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_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,
struct list_head *prev,
struct list_head *next)
{
next->prev = _new;
_new->next = next;
_new->prev = prev;
prev->next = _new;
}
/**
* 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, struct list_head *head)
{
__list_add(_new, 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;
}
#define LIST_POISON1 ((void *) 0x00100100)
#define LIST_POISON2 ((void *) 0x00200200)
/**
* 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;
}
#endif
这里面有个很奇妙的宏:container_of
作用是根据结构体成员的地址,得到整个结构体的地址,具体的实现方法可以自己Google下,这里不多描述。
根据这个list.h文件,这是链表的底层实现,我们不需要更改,
我们写链表时,直接包含这个文件即可:
自己写的链表:
my_list.h:
#ifndef _MY_LIST_H
#define _MY_LIST_H
#include "list.h"
typedef struct list_info
{
int id;
struct list_head list_node;
}list_info;
struct list_head * Create_list(void);
void Add_list_node(struct list_head * head,int id );
void list_for_each(struct list_head * head);
void Del_list_tail(struct list_head * head);
void Destroy_list(struct list_head * head);
#endif
my_list.c:
#include <stdio.h>
#include <stdlib.h>
#include "my_list.h"
#include "list.h"
struct list_head * Create_list(void)
{
struct list_head * head = (struct list_head *)malloc( sizeof(struct list_head) );
if(head == NULL)
printf("create list failed !\n");
else
INIT_LIST_HEAD(head);
return head;
}
void Add_list_node(struct list_head * head,int id )
{
list_info * node = (list_info *)malloc( sizeof(list_info) );
if(node == NULL)
printf("add list_node failed !\n");
else
{
node->id = id;
list_add_tail(&node->list_node,head);
}
}
void list_for_each(struct list_head * head)
{
list_info * pos;
list_for_each_entry(pos, head, list_node)
printf("list_info:%d\n",pos->id);
}
void Del_list_tail(struct list_head * head)
{
struct list_head *pos = head->prev;
if(list_empty(head))
{
printf("list is empyty,delete failed !");
return ;
}
list_del(pos);
free(container_of(pos,list_info,list_node));
}
void Destroy_list(struct list_head * head)
{
struct list_head *pos = head->prev;
while(pos != head)
{
list_del(pos);
free(container_of(pos,list_info,list_node));
pos = head->prev;
}
}
main.c:
#include "my_list.h"
#include <stdio.h>
#include <stdlib.h>
int main()
{
struct list_head * head;
head = Create_list();
Add_list_node(head,5 );
Add_list_node(head,6 );
Add_list_node(head,7 );
printf("list node info :\n");
list_for_each(head);
printf("then delete list tail node info :\n");
Del_list_tail(head);
list_for_each(head);
Destroy_list(head);
return 0;
}
运行结果: