container_of

转载自:http://blog.csdn.net/yinkaizhong/archive/2009/04/20/4093795.aspx


问题：如何通过结构中的某个变量获取结构本身的指针？？？

关于container_of见kernel.h中:
/**
* 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) );})
container_of在Linux Kernel中的应用非常广泛,它用于获得某结构中某成员的入口地址.

关于offsetof见stddef.h中:
#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
TYPE是某struct的类型 0是一个假想TYPE类型struct,MEMBER是该struct中的一个成员. 由于该struct的基地址为0, MEMBER的地址就是该成员相对与struct头地址的偏移量.
关于typeof,这是gcc的C语言扩展保留字,用于声明变量类型.
const typeof( ((type *)0->member ) *__mptr = (ptr);意思是声明一个与member同一个类型的指针常量 *__mptr,并初始化为ptr.
(type *)( (char *)__mptr - offsetof(type,member) );意思是__mptr的地址减去member在该struct中的偏移量得到的地址, 再转换成type型指针. 该指针就是member的入口地址了.


例一；

container_of宏定义在[include/linux/kernel.h]中：

#define container_of(ptr, type, member)     /

const typeof( ((type *)0)->member ) *__mptr = (ptr); /

(type *)( (char *)__mptr - offsetof(type,member) );

offsetof宏定义在[include/linux/stddef.h]中：

#define offsetof(type, member) ((size_t) &((type *)0)->member)
下面用一个测试程序test.c来说明

#include<stdio.h>
struct student{
    char name[20]; 
    char sex;
}stu={"zhangsan",'m'};

main()
{
    struct student *stu_ptr;    //存储container_of宏的返回值
    int offset;            //存储offsetof宏的返回值
//下面三行代码等同于 container_of（＆stu.sex,struct student, sex ）参数带入的情形

    const typeof(((struct student*)0)->sex) *_mptr = &stu.sex;
//首先定义一个 _mptr指针， 类型为struct student结构体中sex成员的类型
//typeof 为获取（（（struct student＊）0）->sex)的类型，此处此类型为char
//（（struct student＊）0）在offsetof处讲解

    offset = (int)(&((struct student *)0)->sex);
/*（（struct student＊）0）为 把 0地址 强制转化为指向student结构体类型的指针
该指针从地址 0 开始的 21个字节用来存放name 与 sex（char name〔20〕与 char sex共21字节）
sex存放在第20个字节出（从0字节开始）
&((struct student *)0)->sex 取出sex地址(此处即为20) 并强制转化为整形
所以offset为20，后面的printf结果将证明这一点*/

    stu_ptr = (struct student *)((char*)_mptr - offset);
/*（（char＊）_mptr - offset）此处先把_mptr指针转化为字符形指针
（为什么这么做呢？ 如果_mptr为整形指针 _mptr - offset 相当于减去 sizeof（int）＊offset个字节）
减去 offset值 相当于 得到_mptr所在结构体的首地址（即stu的地址）
然后我们把 该地址 强制转化为 struct student类型即可正常使用了*/

    printf("offsetof stu.sex = %d/n",offset); 
    printf("stu_ptr->name:%s/tstu_ptr->sex:%c/n", stu_ptr->name, stu_ptr->sex);
    return 0;
}

例二：

它的作用显而易见，那就是根据一个结构体变量中的一个域成员变量的指针来获取指向整个结构体变量的指针。比如，有一个结构体变量，其定义如下：

   1. struct demo_struct {
   2.     type1 member1;
   3.     type2 member2;
   4.     type3 member3;
   5.     type4 member4;
   6. };
   7.
   8. struct demo_struct demo;

同时，在另一个地方，获得了变量demo中的某一个域成员变量的指针，比如 ：

   1. type3 *memp = get_member_pointer_from_somewhere();

此时，如果需要获取指向整个结构体变量的指针，而不仅仅只是其某一个域成员变量的指针，我们就可以这么做：

   1. struct demo_struct *demop = container_of(memp, struct demo_struct, member3);
首先，我们将container_of(memp, struct demo_struct, type3)根据宏的定义进行展开如下：

   1. struct demo_struct *demop = ({                      /
   2.     const typeof( ((struct demo_struct *)0)->member3 ) *__mptr = (memp);    /
   3.     (struct demo_struct *)( (char *)__mptr - offsetof(struct demo_struct, member3) );})

其 中，typeof是GNU C对标准C的扩展，它的作用是根据变量获取变量的类型。因此，上述代码中的第2行的作用是首先使用typeof获取结构体域变量member3的类型为 type3，然后定义了一个type3指针类型的临时变量__mptr，并将实际结构体变量中的域变量的指针memp的值赋给临时变量__mptr。

假设结构体变量demo在实际内存中的位置如下图所示：
     demo
 +-------------+ 0xA000
 |   member1              |
 +-------------+ 0xA004
 |   member2             |
 |                                |
 +-------------+ 0xA010
 |   member3             |
 |                                |
 +-------------+ 0xA018
 |   member4             |
 +-------------+

则，在执行了上述代码的第2行之后__mptr的值即为0xA010。

再看上述代码的第3行，其中需要说明的是offsetof，它定义在include/linux/stddef.h中，其定义如下：

   1. 24#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)

同样，我们将上述的offsetof调用展开，即为：

   1. (struct demo_struct *)( (char *)__mptr - ((size_t) &((struct demo_struct *)0)->member3) );

可见，offsetof的实现原理就是取结构体中的域成员相对于地址0的偏移地址，也就是域成员变量相对于结构体变量首地址的偏移。

因此，offsetof(struct demo_struct, member3)调用返回的值就是member3相对于demo变量的偏移。结合上述给出的变量地址分布图可知，offsetof(struct demo_struct, member3)将返回0x10。

于是，由上述分析可知，此时，__mptr==0xA010，offsetof(struct demo_struct, member3)==0x10。
因此， (char *)__mptr - ((size_t) &((struct demo_struct *)0)->member3) == 0xA010 - 0x10 == 0xA000，也就是结构体变量demo的首地址（如上图所示）。

由此，container_of实现了根据一个结构体变量中的一个域成员变量的指针来获取指向整个结构体变量的指针的功能。

 

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

转载自:http://blog.chinaunix.net/u3/94312/showart_1922123.html

 

1. 我们先写一个小程序：

  1 #include <stdio.h>
  2 #include <stdlib.h>
  3 #include <unistd.h>
  4
  5 typedef struct {
  6     int a;
  7     int b;
  8     int c;
  9 }hehe;
 10
 11 int main(int argc, char *argv[])
 12 {
 13     hehe hoho;
 14     hehe *haha;
 15     hehe *hihi;
 16     int *ptr;
 17
 18     hoho.a = 1;
 19     hoho.b = 2;
 20     hoho.c = 3;
 21     
 22     hihi = &hoho;
 23
 24     ptr = &hoho.b;
 25
 26     printf("ptr = %d, hihi = 0x%08x/n", *ptr, hihi);
 27
 28     haha = ptr - (&hihi->b - (int *) hihi);
 29     printf("a = %d, b = %d, c = %d /n", haha->a, haha->b, haha->c);
 30 }  


程序中定义了一个结构体hehe,它有3个成员a,b,c；用hehe定义hoho，并定义2个hehe类型的指针haha,hihi;初始化hoho的成员a,b,c分别为1,2,3；hihi指向hoho,ptr指向hoho.b;

这样我们要做的就是通过hoho的成员b获得hoho的首地址，也就是28行：

 28     haha = (char *)ptr - (char *)(&hihi->b - (int *) hihi);

要想使haha最终的值为hoho的首地址，那么haha = &hoho = &hoho.b - (&hoho.b - &hoho)
                                     = ptr - hoho.b到hoho的偏移
                                     = ptr - (&hihi->b - (int *) hihi)
因此上述程序编译后执行正确的打印出hoho的a,b,c的值：
$ ./2
ptr = 2, hihi = 0xbfb838dc
a = 1, b = 2, c = 3

2. 接下来我们对这个程序进行修改，从上面的打印结果看到hihi的值为0xbfb838dc，也就是hoho的首地址为0xbfb838dc，而指针其实就 是一个保存一个地址的内存区域，而指针的类型就决定了解析这个地址的方法，因此我们就可以用进行了强制类型转化的地址来代替指针，我想对c语言有所了解的 都能明白这种替换的，ok，那么这里我们作出下面的修改：

 28     haha = ptr - (&((hehe *)(0xbfb838dc))->b - (int *)0xbfb838dc);

因 为hihi为指向一个hehe结构体的指针，因此这里进行替换的时候需要将hihi->b改为((hehe *)(0xbfb838dc))->b，而hihi就直接0xbfb838dc就可以了，不过这里需要加上(int *)，因为b的类型是 int型的，直接进行这种地址的加减的时候一定要保证两个地址对应的类型一致，不然程序会出错。

这样编译后运行：
$ ./2
ptr = 2, hihi = 0xbfea6bfc
a = 1, b = 2, c = 3

恩，打印出来的a,b,c的值还是正确的。

3. 你可能会注意到上面的hihi的值已经发生了变化，这是自然的，每次运行的程序分配的内存地址都不一定相同，这样就会发现一个问题，其实这个结构体在内存 的什么位置都不会有影响，而且这里我们计算的是hoho.b到hoho的偏移，因此hoho的首地址的位置不会对结果有影响，那么就可以有一个结 论&((hehe *)(0xbfb838dc))->b - (int *)0xbfb838dc = &((hehe *)(0x0))->b - (int *)0x0,因此我们对程序作下面的修改：

 28     haha = ptr - (&((hehe *)(0))->b - (int *) 0);

编译后运行：
$ ./2
ptr = 2, hihi = 0xbf9d071c
a = 1, b = 2, c = 3

结果仍然没有问题。

4. 我们再研究一下程序的28行：

 28     haha = ptr - (&((hehe *)(0))->b - (int *) 0);

可以看到&((hehe *)(0))->b - (int *)0，很明显我们可以将程序改为：

haha = ptr - &((hehe *)(0))->b

不过，这里程序必须要加上加上强制类型转换，不然会计算错误，因此程序：

 28     haha = (char *)ptr - (char *)&((hehe *)0)->b;

编译运行之后：
$ ./2
ptr = 2, hihi = 0xbff5fcac
a = 1, b = 2, c = 3

结果仍然正确。

5. 将这个代码写成宏的形式，就可以写成

#define container_of(ptr, type, member) (type *)((char *)ptr - (char *)&((type *)0)->member)

最后将程序改为

  1 #include <stdio.h>
  2 #include <stdlib.h>
  3 #include <unistd.h>
  4
  5 #define container_of(ptr, type, member) (type *)((char *)ptr - (char *)&((type *)0)->member)
  6
  7 typedef struct {
  8     int a;
  9     int b;
 10     int c;
 11 }hehe;
 12
 13 int main(int argc, char *argv[])
 14 {
 15     hehe hoho;
 16     hehe *haha;
 17     hehe *hihi;
 18     int *ptr;
 19
 20     hoho.a = 1;
 21     hoho.b = 2;
 22     hoho.c = 3;
 23
 24     hihi = &hoho;
 25
 26     ptr = &hoho.b;
 27
 28     printf("ptr = %d, hihi = 0x%08x/n", *ptr, hihi);
 29
 30     haha = container_of(ptr, hehe, b);
 31     printf("a = %d, b = %d, c = %d /n", haha->a, haha->b, haha->c);
 32 }
 33

编译后运行：
$ ./2
ptr = 2, hihi = 0xbfe14b5c
a = 1, b = 2, c = 3

结果正确。

最后你只需要对这跟宏稍作一些修改就可以写成文章最开始的那种形式了。

恩，以上就是对container_of宏的推导过程，希望会对大家有所帮助。