第25章结构体进阶

课程目录第25章结构体进阶

结构体进阶：嵌套、动态内存与自引用

结构体这东西，学完基础语法其实只能算入门。真正在项目里用起来，你会发现它远比想象中灵活。今天咱们聊聊结构体的三个进阶玩法——嵌套、动态内存分配、还有自引用。这些技巧我在实际项目中几乎天天用，尤其是链表那块，可以说是嵌入式开发的基石。

一、结构体嵌套：把结构体装进结构体

说白了，结构体嵌套就是一个结构体的成员，本身又是一个结构体。这在实际建模时特别有用。比如你要描述一个学生，除了姓名学号，还有出生日期——日期本身就有年、月、日三个字段，你总不能全写成int吧？

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

// 再定义学生结构体，嵌套Date
struct Student {
    char name[32];
    int id;
    struct Date birthday;  // 嵌套结构体
    float score;
};

访问嵌套成员时，用点号一层层往下走就行：

struct Student stu;
stu.birthday.year = 2000;
stu.birthday.month = 6;
stu.birthday.day = 15;

我的习惯：嵌套结构体时，我一般会把内部结构体定义放在前面，或者用typedef提前声明。不然编译器不认识，会报错。这坑我踩过不止一次。

还有一种情况是结构体里嵌套指针，指向另一个结构体。这其实已经有点链表的意思了，咱们后面细说。

二、结构体与动态内存分配

你想想看，如果结构体里有个数组成员，大小是固定的。但实际数据量可能不确定，比如一个班级的人数。这时候静态数组就尴尬了——开大了浪费内存，开小了不够用。

解决办法？用指针加动态内存分配。

#include <stdlib.h>
#include <string.h>

struct Class {
    int class_id;
    int student_count;
    struct Student *students;  // 指针，指向动态分配的数组
};

// 动态创建班级
struct Class* create_class(int id, int count) {
    struct Class *cls = (struct Class*)malloc(sizeof(struct Class));
    if (!cls) return NULL;
    
    cls->class_id = id;
    cls->student_count = count;
    cls->students = (struct Student*)malloc(count * sizeof(struct Student));
    
    if (!cls->students) {
        free(cls);
        return NULL;
    }
    
    return cls;
}

我曾经犯过一个低级错误：malloc之后忘了检查返回值。结果在嵌入式设备上，内存不足时程序直接崩溃。后来我养成了习惯——每次malloc后必须判断是否为NULL。这习惯救了我好几次。

释放的时候也要小心：先释放内部指针指向的内存，再释放结构体本身。顺序反了就会内存泄漏。

void destroy_class(struct Class *cls) {
    if (cls) {
        free(cls->students);  // 先释放内部数组
        free(cls);            // 再释放结构体
    }
}

三、结构体的自引用：链表节点的灵魂

自引用，就是结构体里有一个指针，指向和自己相同类型的结构体。这听起来有点绕，但其实就是链表节点的核心。

struct Node {
    int data;
    struct Node *next;  // 指向下一个节点
};

为什么能这样写？因为指针本身只占4或8个字节，编译器不需要知道完整结构体大小就能确定指针的布局。所以自引用是合法的。

咱们来创建一个简单的单向链表：

#include <stdio.h>
#include <stdlib.h>

struct Node {
    int data;
    struct Node *next;
};

// 在链表头部插入节点
struct Node* insert_head(struct Node *head, int value) {
    struct Node *new_node = (struct Node*)malloc(sizeof(struct Node));
    if (!new_node) return head;
    
    new_node->data = value;
    new_node->next = head;
    return new_node;
}

// 遍历链表
void print_list(struct Node *head) {
    struct Node *cur = head;
    while (cur) {
        printf("%d -> ", cur->data);
        cur = cur->next;
    }
    printf("NULL\n");
}

核心要点：自引用结构体是实现链表、树、图等动态数据结构的基础。你想想看，如果没有自引用，我们只能用数组模拟链表，那插入删除的效率就大打折扣了。

四、避坑指南：我踩过的那些坑

浅拷贝问题：结构体里有指针时，直接用等号赋值只是复制了地址，两个结构体指向同一块内存。修改一个，另一个也跟着变。我建议用深拷贝——手动分配内存并复制数据。
内存泄漏：动态分配的结构体，用完后一定要free。尤其是链表，遍历释放每个节点，别漏了。
野指针：free之后记得把指针置为NULL。不然就成了野指针，后续误用会出大问题。
对齐与填充：结构体成员之间有内存对齐，大小可能比你想象的大。如果你要序列化结构体到文件或网络，记得用#pragma pack或手动处理填充字节。

五、知识体系总览

下面这张图帮你理清今天讲的内容：

六、综合示例：动态学生管理系统

最后来个综合例子，把今天讲的三个知识点串起来：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct Date {
    int year, month, day;
};

struct Student {
    char name[32];
    int id;
    struct Date birthday;
    struct Student *next;  // 链表指针
};

// 创建学生节点
struct Student* create_student(const char *name, int id, int y, int m, int d) {
    struct Student *s = (struct Student*)malloc(sizeof(struct Student));
    if (!s) return NULL;
    
    strncpy(s->name, name, 31);
    s->name[31] = '\0';
    s->id = id;
    s->birthday.year = y;
    s->birthday.month = m;
    s->birthday.day = d;
    s->next = NULL;
    
    return s;
}

// 插入到链表尾部
void append_student(struct Student **head, struct Student *new_s) {
    if (!*head) {
        *head = new_s;
        return;
    }
    struct Student *cur = *head;
    while (cur->next) cur = cur->next;
    cur->next = new_s;
}

// 打印所有学生
void print_all(struct Student *head) {
    struct Student *cur = head;
    while (cur) {
        printf("ID:%d Name:%s Birthday:%d-%02d-%02d\n",
               cur->id, cur->name,
               cur->birthday.year,
               cur->birthday.month,
               cur->birthday.day);
        cur = cur->next;
    }
}

// 释放整个链表
void free_all(struct Student *head) {
    struct Student *cur = head;
    while (cur) {
        struct Student *tmp = cur;
        cur = cur->next;
        free(tmp);
    }
}

int main() {
    struct Student *list = NULL;
    
    append_student(&list, create_student("张三", 1001, 2000, 6, 15));
    append_student(&list, create_student("李四", 1002, 2001, 3, 22));
    append_student(&list, create_student("王五", 1003, 1999, 11, 8));
    
    print_all(list);
    free_all(list);
    
    return 0;
}

这个例子把嵌套（Date结构体）、动态内存分配（malloc创建节点）、自引用（next指针）全用上了。你想想看，如果没有这些技巧，要实现一个动态增长的学生列表，得费多大劲？

嗯，今天就聊到这儿。结构体进阶这块内容，说白了就是让你能用C语言描述更复杂的数据关系。多写几遍代码，自然就熟练了。

📚 课程目录

结构体进阶：嵌套、动态内存与自引用

一、结构体嵌套：把结构体装进结构体

二、结构体与动态内存分配

三、结构体的自引用：链表节点的灵魂

四、避坑指南：我踩过的那些坑

五、知识体系总览

六、综合示例：动态学生管理系统