第31课 老生常谈的两个宏(linux)

1. Linux内核中常用的两个宏定义

（1）offsetof宏：用于计算TYPE结构体中MEMBER成员的偏移位置

#ifndef offsetof
#define offsetof(TYPE, MEMBER) ((size_t)&((TYPE*)0)->MEMBER)
#endif

（2）container_of宏：根据成员变量指针反推结构体对象的起始地址

//const typeof(...):编译期类型检查，const指针兼容const和非const指针类型
#ifndef container_of
#define container_of(ptr, type, member) ({                 \
        const typeof(((type*))->member)* __mptr = (ptr);  \
        (type*)((char*)__mptr - offsetof(type, member));})
#endif

2. 原理剖析

（1）巧用0地址

　　①编译器清楚的知道结构体成员变量的偏移地址

　　②通过结构体变量首地址与偏移量定位成员变量

【编程实验】offsetof宏

//offsetof.c

#include "stdio.h"

#ifndef offsetof
#define offsetof(TYPE, MEMBER) ((size_t)&((TYPE*)0)->MEMBER)
#endif

struct ST
{
    int  i;  //offset 0
    int  j;  //offset 4
    char c;  //offset 8
};

void func(struct ST* pst)
{
    int* pi = &(pst->i);    //(unsigned int)pst + 0;
    int* pj = &(pst->j);    //(unsigned int)pst + 4;
    char* pc = &(pst->c);   //(unsigned int)pst + 8;

    printf("pst = %p\n", pst);
    printf("pi = %p\n", pi);
    printf("pj = %p\n", pj);
    printf("pc = %p\n", pc);
};

int main()
{
    struct ST s = {};

    func(&s);
    func(NULL);//借用0地址计算成员变量的偏移地址，相当于pst=0

    printf("offset i: %d\n", offsetof(struct ST, i)); //
    printf("offset j: %d\n", offsetof(struct ST, j)); //
    printf("offset c: %d\n", offsetof(struct ST, c)); //

    return ;
}
/*输出结果
pst = 0029FEA4
pi = 0029FEA4
pj = 0029FEA8
pc = 0029FEAC
pst = 00000000
pi = 00000000
pj = 00000004
pc = 00000008
offset i: 0
offset j: 4
offset c: 8
*/

（2）({})是何方神圣

　　①它是GNU C编译器的语法扩展

　　②与逗号表达式类似，结果为最后一个语句的值

（3）typeof关键字

　　①typeof是GNU C编译器的特有关键字

　　②typeof只在编译期生效，用于得到变量的类型

（4）container_of原理

【编程实验】container_of原理

//container_of.c

#include "stdio.h"

#ifndef offsetof
#define offsetof(TYPE, MEMBER) ((size_t)&((TYPE*)0)->MEMBER)
#endif

//const typeof(...):编译期类型检查，const指针兼容const和非const指针类型
#ifndef container_of
#define container_of(ptr, type, member) ({                 \
        const typeof(((type*))->member)* __mptr = (ptr);  \
        (type*)((char*)__mptr - offsetof(type, member));})
#endif

struct ST
{
    int  i;  //offset 0
    int  j;  //offset 4
    char c;  //offset 8
};

//({})是何方神圣
void func()
{
    int a = ;
    int b = ;
    int c = (a=, b=, a+b); //括号表达式
    int d = ({int a=; int b=; a+b;}); //({})表达式，其中的{}表示一个作用域，{}外再加上()表示取最后一个语句的值
                                        //功能上类似于逗号表达式，这是GNU C扩展语法
    printf("c = %d\n", c);
    printf("d = %d\n", d);
}

//typeof关键字：GNU C的扩展关键字
void type_of()
{
    int i = ;
    typeof(i) j = i;
    const typeof(j)* p = &j;

    printf("sizeof(j)= %d\n", sizeof(j));
    printf("j = %d\n", j);
    printf("*p = %d\n", *p);
}

int main()
{
    func();
    type_of();

    struct ST s = {};
    char* pc = &s.c;

    int e = ;
    int* pe = &e; 

    struct ST* pst = container_of(pc, struct ST, c);
    //struct ST* pst = container_of(pe, struct ST, e); //类型检查，编译不过
    printf("&s = %p\n", &s);
    printf("pst = %p\n", pst); //pst == &s;

    return ;
}
/*输出结果
c = 3
d = 3
sizeof(j)= 4
j = 100
*p = 100-
&s = 0029FE94
pst = 0029FE94
*/

3. 小结

（1）编译器清楚地知道结构体成员变量的偏移位置

（2）({})与逗号表达式类似，结果为最后一个语句的值

（3）typeof只在编译期生效，用于得到变量的类型

（4）container_of使用({})进行类型安全检查