#include<stdio.h> #include<stdint.h> /* 求一个struct内的成员MEMBER到这个struct的内存起始处的距离(offset) */ #define offsetof(TYPE,MEMBER) ((size_t)&((TYPE*)0)->MEMBER) /* @ptr 所用的member的指针 * @type 所求的struct的类型名 * @member 所用的member的变量名 */ #define container_of(ptr,type,member) ({ const typeof( ((type*)0)->member ) *__mptr = (ptr); (type *)( (uint8_t *)__mptr - offsetof(type,member) );}) /*第一行：声明一个跟ptr一样类型的指针*/
/*第二行：求出这个指针所指的成员所在的struct的内存起始位置，做类型转换后，就可以得到这个struct的指针*/
struct MyStruct { int i_1; int i_2; int i_3; int i_4; int i_5; int i_6; int i_7; int i_8; int i_9; int i_a; int i_b; int i_c; int i_d; int i_e; int i_f; int i_g; int i_h; int i_j; }; int main() { struct MyStruct Test = { 0,1,2,3,4,5,6,7,8,9,11,12,13,14,15,16,17,18}; printf("Just a test: Test->i_1: %d ",Test.i_1); int *ptr = &(Test.i_2); printf("Now we got i_2: %d ",*ptr); struct MyStruct *struct_ptr = container_of(ptr,struct MyStruct,i_2); /*当使用长得像函数的宏的时候，就可以将一个类型，而不是一个变量，当参数传进去*/ printf("Now we got struct "); printf("Test.i_3 is: %d ",struct_ptr->i_3); return 0; }
由一个struct里的member(成员)的指针得到这个struct的指针，从而可以得到这个struct的其他成员。
通过这种方法，Linux内部就不需要维护一个task_struct的双向链表了，只需要维护task_struct里面的某个成员的双向链表，效果等同于一个task_struct的双向链表。
这样有什么好处呢？好处就是可以通过这种方法达到“范型”的功能！
举个例子：
假如不这样做，那么：
假如要维护task_struct的链表，那么就要写一系列的task_struct的链表操作。。。。
假如又要维护一个task_queue, 那么又要写一系列的操作。。。
假如又有一个task_xxxx，那么就gg了。。。。
但是假如这样的话，就方便多了。
（task_struct是Linux Kernel内部用来描述一个process／thread的struct，维护一个task_struct的双向链表是因为要从一个进程得到其子进程、父进程、兄弟进程......）
可以看出其实这个黑科技之所以能实现主要是因为gcc那个 typeof 操作符......
Links（更清楚的代码）:
Definition of offsetof : http://lxr.free-electrons.com/source/include/linux/stddef.h
Definition of container_of: http://lxr.free-electrons.com/source/include/linux/kernel.h#L840
上面用到的 ((type*)0) 是什么意思？
通过这个转换，可以得到一个类型为 type 的指针，而且其指向的地址是0x00000000。这个转换之后，编译器会“以为”这个指针所指的位置的后面那块地方放着一个类型为 type 的东西（尽管可能不是）
值得说明的是，指针就是指向一个点而已，但是指针的类型决定着它后面可以有多少“属于它”的内存。
但是! 但是! 这里补充说明一点，不要天真的以为你可以用任意类型 t 的指针指向某一块内存，从而掩耳盗铃般地以为后面那块内存就是存放这个类型的变量。
在 C/C++的世界里，有一个规则叫做 Strict Aliasing：
故事的开始是这样的：
由于Ｃ／Ｃ＋＋里头有指针的存在，所以在Strict Aliasing这个规则出来以前，很多人都会做这样的事：
uint32_t foo; uint16_t *bar = &foo; bar[0] = 1; bar[1] = 2;
这个看起来很自然，毕竟，人家就是将一块内存分成两块，然后分别对两块进行操作.......
但是，这样做有很多问题：
第一，直接无视了big-endian和little-endian的机器的区别。
第二，严重的妨碍了编译器做优化。要知道，编译器在做优化的时候，如果发现在某个过程中，某个值 X 看起来没有修改过，或者根本就没人引用它，他就真的会直接地以为这个值根本没有被修改过，所以，这个过程之后，如果 X 已经被放在了寄存器中，当再次被使用的时候，编译器就会直接从寄存器中取这个值，而不会再次取查看内存中的 X 。所以，如果像上面的代码那样的话，编译器优化的结果就是错的了。
在远古时期，很多程序员都会干这种事。那时候的编译器作者苦啊，辛辛苦苦做优化，做出来结果却不正确，明明错不在自己，还要被人批。
所以，为了解决这个问题，Ｃ／Ｃ＋＋标准规定了：
From C9899:201x 6.5 Expressions:
7 An object shall have its stored value accessed only by an lvalue expression that has one of the following types:— a type compatible with the effective type of the object,
— a qualified version of a type compatible with the effective type of the object,
— a type that is the signed or unsigned type corresponding to the effective type of the object,
— a type that is the signed or unsigned type corresponding to a qualified version of the effective type of the object,
— an aggregate or union type that includes one of the aforementioned types among its members (including, recursively, a member of a subaggregate or contained union), or
— a character type.
什么意思呢？就是，假如有一个 long 类型的变量，如果你用一个 int 类型的指针去指向它，那么你的行为就是非法的，未定义的了，编译器将不会对你的代码的结果做出任何保证。当然，你可以用 unsigned long 或者 unsigned long volatile 之类的指针指向它，这还是合法的。这就是Strict Aliasing。
有一个例外：你可以用 char 类型的指针指向任何东西（看标准的最后一条）。
还有一个例外，关于union结构体的。这个在C99标准之内，但是不在C++标准之内（但是我觉得大多数编译器还是会默认这种行为正确的）。我就不说明了，给一个错误的例子和正确的例子自己找差别：
错误的例子（结果Undefined）：
uint32_t swaphalves(uint32_t a) { uint32_t acopy=a; uint16_t *ptr=(uint16_t*)&acopy;// can't use static_cast<>, not legal. // you should be warned by that. uint16_t tmp=ptr[0]; ptr[0]=ptr[1]; ptr[1]=tmp; return acopy; //由于你用unint_16的指针指向一个uint32_t的变量，编译器当做没看到，然后就以为acopy根本就没有被修改过（因为没有东西指向acopy)，
//很有可能会直接将一开始的acopy直接返回（点击博文下面的链接【１】看汇编） } int main() { uint32_t a; a=32; cout << hex << setfill('0') << setw(8) << a << endl; a=swaphalves(a); cout << setw(8) << a << endl; }
将上面的 swaphalves 改成这样之后就是正确的了：
uint32_t swaphalves(uint32_t a) { typedef union { uint32_t as32bit; uint16_t as16bit[2]; } swapem; swapem s={a}; uint16_t tmp; tmp=s.as16bit[0]; s.as16bit[0]=s.as16bit[1]; s.as16bit[1]=tmp; return s.as32bit; }
几个关于Strict Aliasing的的链接：
【１】：http://dbp-consulting.com/tutorials/StrictAliasing.html （我觉得讲得最好的）
【２】：http://cellperformance.beyond3d.com/articles/2006/06/understanding-strict-aliasing.html （引用率比较高的）
【３】：http://stackoverflow.com/questions/98650/what-is-the-strict-aliasing-rule （肯定要有stackoverflow。。。）
最后还有一点，关于 restrict 这个关键字：
void foo(int * restrict i1, int * restrict i2);
通过 restrict 关键字，程序员向编译器保证， r1 和 r2 不会指向相同的内存，这样编译器就可以放胆进行优化了。当然，如果两者真的指向相同的内存，后果自负。
（Ｃ＋＋中没有register这个关键字，但是很多编译器都有形如 __restrict 或 __restrict__ 的扩展。
Link：
【１】： http://cellperformance.beyond3d.com/articles/2006/05/demystifying-the-restrict-keyword.html
（其实这些东西，包括上一篇的 volatile 关键字，的奇奇怪怪的原因与应用，都跟编译器的优化有关，看出来没有。。。。。。）
：）