5. 结构体嵌套：结构体成员为另一个结构体、嵌套初始化、访问嵌套成员

结构体嵌套，说白了就是一个结构体里面套着另一个结构体。这在实际开发中太常见了——你想想看，现实世界里的对象哪个不是层层嵌套的？一辆车有发动机，发动机又有活塞、曲轴……用代码描述这种关系，嵌套结构体就是最自然的表达方式。

5.1 什么是结构体嵌套

先看一个最简单的例子。假设我们要描述一个学生的信息，学生有姓名、学号，还有出生日期。日期本身又是一个结构体，包含年、月、日。这就形成了嵌套：

// 先定义日期结构体
struct Date {
    int year;
    int month;
    int day;
};

// 学生结构体，嵌套了Date
struct Student {
    char name[32];
    int id;
    struct Date birthday;  // 成员是另一个结构体
};

你看，birthday这个成员的类型是struct Date，而不是基本类型。这就是嵌套——结构体的成员本身也是一个结构体。

5.2 嵌套初始化

嵌套结构体的初始化，我习惯用大括号层层包裹。每一层大括号对应一层结构体：

// 方式一：完全嵌套初始化（推荐）
struct Student stu1 = {
    "张三",
    1001,
    {2000, 5, 15}  // 对应birthday的year, month, day
};

// 方式二：平铺初始化（C99支持）
struct Student stu2 = {
    "李四",
    1002,
    2001, 3, 20   // 编译器会自动匹配到birthday的成员
};

// 方式三：指定初始化器（C99，可读性最好）
struct Student stu3 = {
    .name = "王五",
    .id = 1003,
    .birthday = {.year = 1999, .month = 12, .day = 1}
};

我个人最推荐方式一和方式三。方式二虽然省了几个大括号，但可读性差——你一眼看过去，分不清2001是学生的什么字段。我在项目中吃过这个亏，代码review时同事看了半天才明白。

5.3 访问嵌套成员

访问嵌套成员，说白了就是「剥洋葱」——用点号一层层往下找。语法很直观：

struct Student stu = {"赵六", 1004, {1998, 7, 22}};

// 访问嵌套成员
printf("姓名: %s\n", stu.name);
printf("出生年份: %d\n", stu.birthday.year);   // 两层点号
printf("出生月份: %d\n", stu.birthday.month);  // 两层点号
printf("出生日期: %d\n", stu.birthday.day);    // 两层点号

// 修改嵌套成员
stu.birthday.year = 1997;

如果有指针指向结构体，用箭头操作符->：

struct Student *p = &stu;
printf("年份: %d\n", p->birthday.year);  // 箭头+点号混合使用

这里要注意：p->birthday.year等价于(*p).birthday.year。箭头操作符的优先级高于点号，所以不需要加括号。但如果你心里没底，加括号总没错——我刚开始学的时候也经常搞混优先级。

5.4 嵌套结构体的内存布局

嵌套结构体在内存中是连续存放的。外层结构体的成员按定义顺序排列，被嵌套的结构体作为一个整体占据一段连续空间。举个例子：

struct Point {
    int x;
    int y;
};

struct Rectangle {
    struct Point topLeft;     // 8字节（假设int占4字节）
    struct Point bottomRight; // 8字节
};  // 总共16字节，不考虑对齐

内存布局是这样的：

地址偏移:  0    4    8    12
          +----+----+----+----+
          | x  | y  | x  | y  |
          +----+----+----+----+
          | topLeft  |bottomRight|
          +----------+----------+

5.5 多层嵌套与自引用

嵌套可以不止一层。比如一个公司有部门，部门有员工，员工有地址……理论上你想嵌套多少层都行：

struct Address {
    char city[32];
    char street[64];
    int zip;
};

struct Employee {
    char name[32];
    struct Address addr;  // 第二层嵌套
};

struct Department {
    char deptName[32];
    struct Employee manager;  // 第三层嵌套
    struct Employee staff[10];
};

struct Company {
    char companyName[64];
    struct Department depts[5];  // 第四层嵌套
};

访问最内层的成员：

struct Company c = {0};
c.depts[0].manager.addr.zip = 100086;  // 一路点下去

嗯，这里要注意：嵌套层数太多，代码会变得又臭又长。我建议超过三层就考虑用指针或者重新设计结构——别让代码变成「俄罗斯套娃」。

5.6 嵌套结构体作为函数参数

把嵌套结构体传给函数，有两种方式：传值或传指针。

// 传值（拷贝整个结构体，开销大）
void printStudent(struct Student s) {
    printf("%s, %d-%d-%d\n", s.name, 
           s.birthday.year, s.birthday.month, s.birthday.day);
}

// 传指针（推荐，只拷贝4/8字节）
void printStudentPtr(const struct Student *s) {
    printf("%s, %d-%d-%d\n", s->name, 
           s->birthday.year, s->birthday.month, s->birthday.day);
}

嵌套结构体往往体积较大，传值会导致整个结构体被拷贝到栈上，效率低。我一般都用指针，加上const修饰防止意外修改。

5.7 嵌套与联合体的组合

有时候结构体嵌套联合体，能做出很灵活的数据结构。比如一个消息包，可能是文本消息也可能是二进制数据：

struct Message {
    int type;  // 0:文本, 1:二进制
    union {
        char text[256];
        struct {
            uint8_t *data;
            size_t len;
        } binary;
    } content;  // 嵌套联合体
};

这种设计在嵌入式通信协议中很常见。我做过的一个物联网项目，就用这种结构处理不同格式的传感器数据——省内存，又清晰。