12. 结构体与宏：offsetof宏的实现、container_of宏、利用宏简化结构体操作

结构体和宏的组合，是C语言里非常硬核的一对搭档。说实话，很多嵌入式工程师写了几年代码，可能都没真正搞懂offsetof和container_of到底是怎么工作的。我当年刚入行时也是这样，直到有一次调试一个内核驱动，被一个野指针折磨了三天……嗯，从那以后我就把这两个宏彻底吃透了。

今天咱们就把这块硬骨头啃下来。你想想看，搞懂了它们，你就能写出更通用、更优雅的代码，尤其是在驱动开发和操作系统底层编程中，这几乎是必备技能。

12.1 offsetof宏：结构体成员的偏移量

offsetof定义在标准头文件<stddef.h>中。它的作用很简单：计算结构体中某个成员相对于结构体起始地址的字节偏移量。

原型长这样：

#define offsetof(type, member) ((size_t)&((type *)0)->member)

我第一次看到这个宏时，心里直犯嘀咕：(type *)0？这不是空指针吗？对空指针取成员地址，不会崩溃吗？

别急，这里有个关键点：编译器并不会真的去访问地址0。它只是在编译阶段计算偏移量，不产生任何运行时内存访问。说白了，就是骗编译器说“假设结构体在地址0”，然后取成员的地址，这个地址值自然就是偏移量。

举个例子：

#include <stdio.h>
#include <stddef.h>

typedef struct {
    char a;      // 偏移0
    int b;       // 偏移4（对齐到4字节）
    short c;     // 偏移8
    double d;    // 偏移16（对齐到8字节）
} MyStruct;

int main() {
    printf("a: %zu\n", offsetof(MyStruct, a));
    printf("b: %zu\n", offsetof(MyStruct, b));
    printf("c: %zu\n", offsetof(MyStruct, c));
    printf("d: %zu\n", offsetof(MyStruct, d));
    return 0;
}

输出结果：

a: 0
b: 4
c: 8
d: 16

看到没？d的偏移是16，不是12。这是因为double需要8字节对齐，编译器在c后面填充了6个字节。嗯，这里要注意：结构体成员的对齐规则会影响偏移量，写跨平台代码时一定要小心。

12.2 container_of宏：从成员指针反推结构体指针

container_of是offsetof的逆操作。它已知结构体中某个成员的地址，反推出整个结构体的起始地址。这个宏在Linux内核中随处可见，是驱动开发的核心工具。

标准实现：

#define container_of(ptr, type, member) ({                      \
    const typeof(((type *)0)->member) *__mptr = (ptr);          \
    (type *)((char *)__mptr - offsetof(type, member)); })

这个宏看起来有点吓人，但拆开看其实很简单：

1. typeof(((type *)0)->member)：获取成员的类型
2. const ... *__mptr = (ptr)：把传入的指针转成成员类型的指针，保存到临时变量
3. (char *)__mptr - offsetof(type, member)：用成员地址减去偏移量，得到结构体起始地址

为什么要多此一举用__mptr？直接(char *)(ptr) - offsetof(...)不行吗？

我曾经也这么想，直到有一次我传了一个int *进去，而成员是short类型……编译器连警告都不给，直接算错。而container_of用typeof做了类型检查，类型不匹配会报编译错误。这就是专业代码和业余代码的区别。

看个实际例子：

#include <stdio.h>
#include <stddef.h>

#define container_of(ptr, type, member) ({                      \
    const typeof(((type *)0)->member) *__mptr = (ptr);          \
    (type *)((char *)__mptr - offsetof(type, member)); })

typedef struct {
    int id;
    char name[32];
    int score;
} Student;

void print_student_by_score(int *score_ptr) {
    Student *stu = container_of(score_ptr, Student, score);
    printf("Student: id=%d, name=%s, score=%d\n",
           stu->id, stu->name, *score_ptr);
}

int main() {
    Student s = {1001, "Alice", 95};
    print_student_by_score(&s.score);
    return 0;
}

这个例子中，print_student_by_score只接收一个int *参数，但它能通过container_of找到整个Student结构体。这在回调函数、链表操作中非常有用。

12.3 利用宏简化结构体操作

在实际项目中，我经常用宏来封装一些重复的结构体操作。这样代码更简洁，也更容易维护。

12.3.1 结构体初始化宏

#define STUDENT_INIT(id_val, name_val, score_val) \
    { .id = (id_val), .name = (name_val), .score = (score_val) }

// 使用
Student s = STUDENT_INIT(1002, "Bob", 88);

这样写的好处是：如果结构体增加了字段，只需要改宏定义，所有初始化代码自动更新。我习惯把这类宏放在结构体定义的下方，方便维护。

12.3.2 结构体遍历宏

假设我们有一个链表结构：

typedef struct list_node {
    struct list_node *next;
    int data;
} ListNode;

#define for_each_node(head, node) \
    for (ListNode *node = (head); node != NULL; node = node->next)

// 使用
ListNode *head = /* ... */;
for_each_node(head, cur) {
    printf("%d\n", cur->data);
}

你想想看，如果没有这个宏，每次遍历都要写三行循环头，还容易写错。用宏封装后，代码意图一目了然。

12.3.3 结构体成员访问宏

对于深层嵌套的结构体，访问成员时写起来很痛苦：

typedef struct {
    int x;
    int y;
} Point;

typedef struct {
    Point top_left;
    Point bottom_right;
} Rect;

typedef struct {
    Rect bounds;
    int color;
} Widget;

// 传统写法
Widget w;
w.bounds.top_left.x = 10;

// 用宏简化
#define WIDGET_LEFT(w)      ((w).bounds.top_left.x)
#define WIDGET_TOP(w)       ((w).bounds.top_left.y)
#define WIDGET_RIGHT(w)     ((w).bounds.bottom_right.x)
#define WIDGET_BOTTOM(w)    ((w).bounds.bottom_right.y)

WIDGET_LEFT(w) = 10;
WIDGET_TOP(w) = 20;

12.4 知识体系总览

下面这张图总结了本章的核心知识点和它们之间的关系：

12.5 实际项目中的注意事项

最后，分享几个我在项目中积累的经验：

• 不要滥用宏：宏虽然强大，但调试困难。如果逻辑复杂，优先考虑内联函数。
• 注意宏的副作用：比如MAX(a++, b)这种，参数会被多次求值。写宏时多用括号包裹参数。
• container_of的指针类型要匹配：传进去的指针必须是结构体成员的地址，不能是其他类型。
• 跨平台时注意对齐：不同编译器的对齐规则可能不同，offsetof的结果也可能不同。

---

公众号:蓝海资料掘金营，微信deep3321