Linux链表关键词 和 原理

----------------------------------------关键词 --------------------------------------------------------------------------------------------------------

//1,定义,并分配一个链表头.
struct stdio_dev {
	int	flags;		 
	int	ext;		 
	char	name[16];	 
	void *priv;		 
	struct list_head list;
};

static struct stdio_dev devs;
INIT_LIST_HEAD(&(devs.list));

//2,添加成员. ,2个参数,第一为要添加的新成员,第二个为链表头.
static __inline__ void list_add(struct list_head *new, struct list_head *head)
list_add_tail(&(_dev->list), &(devs.list));
//3,删除成员. 只要知道要删除的成员地址即可//这里只是对链表指针操作,后面应该释放成员内存.
list_del(&(dev->list));
//4,遍历成员 ,为devs.list为链表头.  list是 struct stdio_dev的链表成员名称.
	struct list_head *pos;
	struct stdio_dev *dev;
	list_for_each(pos, &(devs.list)) {
		dev = list_entry(pos, struct stdio_dev, list);
		if(strcmp(dev->name, name) == 0)
			return dev;
	}



--------------------实现原理-------------------------------------------------------------------------------------------------------------------------------

   链表是一种重要的数据结构,应用的非常广泛。链表分为单向链表与双向链表,一般的实现就是在结构体中内嵌指向下一个元素的指针。例如:

[cpp]  view plain copy
  1. struct name {  
  2.     int num;  
  3.     ...;  
  4.     struct name *next;  
  5.     struct name *prev;  
  6. }   
        但是linux内核中的实现确有点特殊他是通过独立定义一个链表结构,通过结构体中内嵌这个结构来完成的,这样就实现了链表的定义与结构体的分离。linux内核中广泛的应用了这种链表,可以这么说,如果没有linux list_head链表就不会有现在linux的强大。本来我就以为只有linux内核用这种链表,但是当我分析完lsusb的代码后,发现这个程序也是用内核链表来组织数据结构的,我想Kroah-Hartman不愧为内核的维护者,连应用程序都带着内核的影子。我就试着在应用程序中使用这种链表,发现他的非常的好用,只要包含list.h,然后在结构体重嵌入这种链表,就能方便的实现数据结构的线性链接。下面我就简单的介绍一下这种链表的实现原理。
        list.h中首先定义了这样一个结构体,这个是链表的基本结构:
[cpp]  view plain copy
  1. struct list_head {  
  2.     struct list_head *next, *prev;  
  3. };  
        我们使用的时候,在自己的结构体中内嵌这个结构就行了,如下;
[cpp]  view plain copy
  1. struct my_struct {  
  2.     int a;  
  3.     int b;  
  4.     ...  
  5.     struct list_head list;  
  6. }  
         这个链表链接起来的不是结构体本身,而是list_head结构。需要一个链表头,这个链表头是list_head结构,不需要内嵌在任何结构中,在使用链表的时候要定义以及初始化这样一个结构。list.h中已经定义了宏用于定义与初始化链表头,如下:
[cpp]  view plain copy
  1. #define LIST_HEAD_INIT(name) { &(name), &(name) }  
  2.   
  3. #define LIST_HEAD(name) \  
  4.     struct list_head name = LIST_HEAD_INIT(name)  
  5.   
  6. #define INIT_LIST_HEAD(ptr) do { \  
  7.     (ptr)->next = (ptr); (ptr)->prev = (ptr); \  
  8. while (0)  
         LIST_HEAD(name)宏用来定义一个链表头,使得他的两个指针都指向自己。我们可以直接在程序的变量声明处,直接调用LIST_HEAD(name)宏,来定义并初始化一个名为name的链表,也可以先声明一个链表,调用INIT_LIST_HEAD来初始化这个链表。从宏定义山看不能直接使用LIST_HEAD_INIT,它只适合声明初始化。
        定义了一个链表后,最重要的操作是向链表添加元素,与删除元素以及遍历链表。下面先说添加元素的操作:
[cpp]  view plain copy
  1. static inline void __list_add(struct list_head *new,  
  2.                   struct list_head *prev,  
  3.                   struct list_head *next)  
  4. {  
  5.     next->prev = new;  
  6.     new->next = next;  
  7.     new->prev = prev;  
  8.     prev->next = new;  
  9. }  
  10.   
  11. static inline void list_add(struct list_head *newstruct list_head *head)  
  12. {  
  13.     __list_add(new, head, head->next);  
  14. }  
  15. static inline void list_add_tail(struct list_head *newstruct list_head *head)  
  16. {  
  17.     __list_add(new, head->prev, head);  
  18. }  

        向链表添加元素只知道链表的头与新的元素地址就可以了,因为链表是双向循环链表,链表头的前一个元素就是这个链表的最后一个元素。list_add是将新元素添加到链表头的后面,而list_add_tail是将心元素添加到链表的尾部,这两个操作如下图所示:

图 1 list_add操作



图 2 list_add_tail操作

        说完了添加元素,下面说一下如何删除链表元素,如下:

[cpp]  view plain copy
  1. static inline void __list_del(struct list_head *prev, struct list_head *next)  
  2. {  
  3.     next->prev = prev;  
  4.     prev->next = next;  
  5. }  
  6.   
  7. static inline void list_del(struct list_head *entry)  
  8. {  
  9.     __list_del(entry->prev, entry->next);  
  10. }  
        删除链表元素也非常简单,只需要找到前一个元素与后一个元素,将他们链接在一起就可以了。
        list_head链表最重要的特点就是链表操作与结构体分离,用list_head链接的链表结构上如下图所示:

图 3 list_head链表特点
         但是我们使用链表的目的不是链表本身,而是内嵌链表的结构体,我们可以方便的遍历list_head结构,如下:
[cpp]  view plain copy
  1. for ( mylist = mylist_head->next; mylist != mylist_head; mylist = mylist->next);  
        但是这样的程序没有什么作用,我们需要的是结构体。所以需要一种技术使得由list_head的地址找到内嵌他的结构提的地址,这个技术就是内核中顶顶大名的container_of宏,这个宏就是list_head链表的精髓,它的初衷是为了实现由结构体的元素的地址而找到结构体首地址。借鉴这种技术就可以实现我们的目的。如下:
[cpp]  view plain copy
  1. #define list_entry(ptr, type, member) \  
  2.     ((type *)((char *)(ptr)-(unsigned long)(&((type *)0)->member)))  
        这个宏实现非常的简单,但是往往伟大的思想就蕴藏在简单的代码中,我们来分析一下这个宏。首先他是一个带参数的宏,有三个参数第一个参数是一个地址,他是结构体中元素的地址,第二个参数是结构体类型,第三个参数是,元素在结构体中的名字。我们以list_head链表为例来说明。例如有如下结构:
[cpp]  view plain copy
  1. struct my_struct {  
  2.     int a;  
  3.     char b;  
  4.     ...  
  5.     strcut list_head list;  
  6. }  
        我们知道了里面的list_head元素的地址为plist,需要找到类型问struct my_struct结构变量的地址。就需要这样调用宏
struct my_struct *ptr = list_entry(plist, struct my_struct, list);
        list_entry宏实现的非常巧妙,括号比较多,让我们将这个宏分解来看。
((type *)((char *)(ptr)-(unsigned long)(&((type *)0)->member)))
        最外面的一层括号可以去掉,这是为了防止宏扩展的,去掉如下:
(type *) ((char *)(ptr)-(unsigned long)(&((type *)0)->member))
        现在就比较清楚了,首先(type *)是C强制转换操作,就是将后面的的数据转化成type结构的指针。而后面的操作可以再分解
(char *)(ptr) - (unsigned long)(&((type *)0)->member)
        这样就是一个减法的操作,前面是一个指针,我们传过去的结构体元素的指针,这里被转化成指向字符的。而后面是一个长整形,可以再分解
(unsigned long) (&((type *)0)->member)
        显然这个长整形是一个指针转化的,而这个指针又可以再分解,
&((type *)0)->member
       可以看出这个指针是一个变量取地址得到的,这个变量又是什么呢
((type *)0)->member 
       看起来有点奇怪,不过这个操作是整个宏中最精妙的,他将地址0转化成type类型,接下来又取得这个结构的member元素,member就是我们传进来的参数:元素在结构体中的命名。其实((type *)0)->member取的变量是内容是什么一点都不重要,重要的我们要取这个变量的地址。取完这个地址将它转换成unsigned long类型,这样这个数据就是((type *)0)->member相对与地址0的偏移。回到上面的那个减法,将结构体中元素的地址与他与结构体首地址的偏移相减,不就得到了结构体的地址了吗。整个操作如下图所示:
图 4 list_entry 宏


评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值