写C语言写了十多年，我一直觉得结构体是最能体现“C语言是工程师的语言”这个特点的特性之一。
你去看市面上大部分C语言教程，讲结构体时基本都在让你背语法：struct关键字、成员列表、声明变量、用点号访问成员。背完语法之后呢？你发现你写代码还是只会用int、char、float这些基础类型，遇到稍微复杂点的数据就手忙脚乱。比如要描述一个学生，姓名是字符数组，学号是整数，三门课成绩是浮点数，如果不用结构体，你就得同时维护五六个孤零零的变量，然后在一堆变量名里来回倒腾。
这篇文章我想换个讲法，不再对着标准语法干念。我会直接站在一个实际开发者的角度，把我从接触结构体到真正能熟练使用它这条路上摸到的门道、掉进去过的坑、以及后来才想明白的原理，一次性讲清楚。文章适合刚学完数组、指针，准备接触自定义类型的初学者，也适合写了一段时间C代码但觉得结构体用不熟练的人参考。
1. 从散装变量到聚合数据：结构体在解决什么问题
1.1 当多个变量描述同一件事物时，维护成本有多大
先别急着看语法。你回想一下自己写代码时有没有遇到过这种情况：
你手里有一个学生信息，包含姓名、学号、语文成绩、数学成绩、英语成绩。不用结构体，你只能这么写：
char name[20]; int id; float chinese_score; float math_score; float english_score;然后你再引入一个学生，就要用这样一组变量：
char name2[20]; int id2; float chinese_score2; float math_score2; float english_score2;十个学生呢？要么复制十遍，要么退回到数组。用数组的话又很别扭：
char names[10][20]; int ids[10]; float chinese[10]; float math[10]; float english[10];这种写法叫“平行数组”，一行存一种属性。看起来挺规整对吧？但你仔细想想：数组下标i能把这些数据串起来，是因为你人为规定了“下标相同表示同一个学生”。这是一种约定，不是代码本身的约束。
结果就是，你排序的时候要注意，交换names[i]和names[j]的同时，必须同步交换ids[i]、chinese[i]、math[i]、english[i]；漏掉一个，整个数据就错位了。新手经常在冒泡排序里只换了成绩数组，忘了换姓名数组，最后打印出来姓名和成绩对不上。我当年就干过这种事，排查了一下午，最后发现sort之后学生A的成绩挂在了学生B的名字下面。
这些散装变量本质上是在用“位置”强行拼凑“关系”。这种写法的代码不是不能跑，而是跑起来之后维护成本极高。数据一多，你脑子里要同时记住七八个数组之间的对应关系，人脑是记不住的。
1.2 结构体让“类型”成为可以自定义的东西
结构体的核心思想，其实就一句话：把多个逻辑上相关的成员打包成“一种新的数据类型”。
定义一个学生结构体，就像在C语言系统里登记一种新的“属性组合”：
struct Student { char name[20]; int id; float chinese_score; float math_score; float english_score; };定义好之后，struct Student就是C语言里的一种新类型。你可以像用int一样去声明变量、去给变量赋值、去作为函数参数传递：
struct Student stu1; struct Student stuArray[10];这才是“自定义类型”这个说法的准确含义。很多人以为自定义类型就是typedef int MyInt这种给基础类型起个别名，其实那只是“别名”，并没有生成新东西。结构体才是真正意义上由程序员设计出来的复合类型，它把零散的成员组织成了一个整体对象。
一旦你习惯了这种组织方式，再回头看平行数组那种写法，你会发现自己已经在用“对象”的视角思考问题了。
1.3 什么样的场景应该用结构体，什么样的场景不必用
结构体不是用得越多越好。我见过一些刚学会结构体的同学，恨不得把两三个整数也包成一个结构体，理由是要“面向对象”。这属于过度设计。
我的判断标准很简单：
**需要同时维护多个关联属性，并且这些属性会作为一个整体被执行增删改查操作时，用结构体。**典型场景包括：
- 学生信息、员工档案、图书条目、订单记录这类“业务实体”
- 配置项，比如网络连接的IP、端口、超时时间、重试次数
- 链表节点、树节点这种需要把“数据”和“指针”绑在一起的数据结构
- 协议报文，把头部字段和负载数据定义成一个结构体，方便填充和解析
不需要用结构体的场景也明确：如果你只是临时算两个数，或者整型数据之间没有任何“一起移动”的需求，那直接基础类型加数组就够了。强行加结构体只会让代码变得更加绕，访问成员要多打几个字还不说，传参时还得考虑拷贝开销。
2. struct语法剖析：定义、声明变量与初始化
2.1 struct关键字后面到底跟的是什么
先看标准定义语法：
struct 结构体标签 { 类型 成员名1; 类型 成员名2; ... };很多人搞不清这里“结构体标签”和“结构体类型”的区别。其实很简单：struct Student这个整体合在一起才构成一个完整的类型名。Student这个标签本身没有类型含义，你需要写struct Student时，C编译器才能明白你说的是哪个结构体类型。
所以在函数参数里你会看到这种写法：
void printStudent(struct Student stu);注意，是struct Student，不是Student。除非你用typedef做了别名（后面第6节会专门讲），否则Student这个名词在C语言里不存在。
理解这点之后，你就能看懂为什么有些代码定义结构体时会在末尾写上几个变量名：
struct Point { int x; int y; } p1, p2; // 定义类型的同时声明了两个变量这种写法合法，等价于：
struct Point { int x; int y; }; struct Point p1, p2;但第一种写法有个缺点：类型定义和变量声明混在一起，如果你既想以后继续用struct Point声明新变量，又在这里顺手声明了p1、p2，很多人会看漏p1、p2的存在，以为这就是一个纯类型定义。所以我个人更推荐第二种写法：定义类型时只定义类型，声明变量时清晰写明。代码可读性这东西，是慢慢积累出来的。
2.2 三种声明结构体变量的写法及匿名结构体
声明结构体变量最常见的就是直接写：
struct Student stu1;如果你确定这个结构体只在这个翻译单元里用一次，不想再为它设计标签，可以用匿名结构体：
struct { char name[20]; int id; } stu1, stu2;注意，匿名结构体因为没有标签，你无法在后面继续写struct xxx来声明更多同类型变量，只能靠定义时列出的变量名。一般也就定义全局结构体变量时偶尔用用，日常开发不建议这么搞。原因很简单：不方便复用。
还有一种情况是成员是另一个结构体类型时，需要先定义内部的那个结构体：
struct Date { int year; int month; int day; }; struct Student { char name[20]; struct Date birthday; // 成员的类型是另一个结构体 };这里稍微注意一下定义顺序：struct Date必须出现在struct Student之前，否则编译器遇到struct Date时会觉得这是一个不完整的类型，直接报错。
2.3 聚合初始化、指定初始化与整体赋值
定义结构体变量之后，最常见的操作就是初始化。C语言给结构体提供了聚合初始化语法，也就是在一对大括号里按成员顺序给值：
struct Student stu1 = {"Tom", 2024001, 88.0, 76.5, 91.0};这里顺序必须和成员定义一致：name、id、chinese_score、math_score、english_score。少给几个也没问题，后面自动补0，但C语言不会提示你错误。如果你把2024001写成了字符串，编译器会在警告层级提示类型不匹配，但如果你把语文成绩和数学成绩位置写反了，程序不会报错，只是数据错了。这种错误很难查。
更稳妥的方式是使用C99标准引入的指定初始化，直接点名要初始化哪个成员：
struct Student stu1 = { .name = "Tom", .id = 2024001, .chinese_score = 88.0, .math_score = 76.5, .english_score = 91.0 };这样写的好处有三个：成员顺序随便调整；跳过的成员自动补0；代码的可读性大幅提升，直接能看到这个成员对应的用途。从C99开始，主流编译器都支持这种写法，我建议新手直接养成用指定初始化的习惯。
结构体变量之间还有一个非常好用的特性：同类型结构体可以直接整体赋值。
struct Student stu2; stu2 = stu1; // 逐成员拷贝，相当于 memcpy这个特性是C语言为了防止程序员犯低级错误而设计的：既然类型一样，干脆每个字节都复制过去，不需要你挨个成员复制。注意赋值的两个结构体必须类型完全相同；如果一个是struct Student另一个是struct Student的typedef别名，那还是同一个类型；如果成员一致但类型名不同，也不能直接赋值，编译器会认为类型不同。
这里顺便提一个新手最容易犯的问题：结构体变量不能直接用==比较。
if (stu1 == stu2) { ... } // 编译错误为什么不能？因为结构体变量里可能包含填充字节，填充字节的值是不确定的，即使两个结构体的逻辑内容完全一样，填充字节也可能不同；而且成员如果有浮点数，浮点比较本身有精度问题，==就直接交底了。正确做法是挨个成员比较，或者用memcmp（但memcmp也会比较填充字节，更稳妥的仍是写比较函数逐成员比较）。
3. 结构体数组：批量记录的标准解
3.1 定义结构体数组并初始化
结构体是一种类型，而类型可以放到数组里。结构体数组的定义方式和普通数组完全一致：
struct Student class[3];初始化时，每个元素都是一个大括号包起来的结构体：
struct Student class[3] = { {"Tom", 2024001, 88.0, 76.5, 91.0}, {"Jerry", 2024002, 92.0, 85.0, 78.5}, {"Alice", 2024003, 79.0, 88.5, 95.0} };如果使用了指定初始化，也可以写成这样：
struct Student class[3] = { [0] = {.name = "Tom", .id = 2024001}, [2] = {.name = "Alice", .id = 2024003} };这里class[1]会被自动清零。指定下标初始化在嵌入式配置表里非常好用，比如你要定义一张设备配置表，只需要指定个别项的初始值，其他项保持默认，会让代码特别清爽。
3.2 遍历、查找与排序操作的代码示例
结构体数组最常见的操作就是遍历。下面这段代码实现了两个需求：找出总分最高的学生，以及打印所有不及格科目对应的学生信息：
#include <stdio.h> #include <string.h> struct Student { char name[20]; int id; float chinese_score; float math_score; float english_score; }; float total(struct Student s) { return s.chinese_score + s.math_score + s.english_score; } int main(void) { struct Student class[3] = { {"Tom", 2024001, 88.0, 76.5, 91.0}, {"Jerry", 2024002, 92.0, 85.0, 78.5}, {"Alice", 2024003, 79.0, 88.5, 95.0} }; int best = 0; for (int i = 1; i < 3; i++) { if (total(class[i]) > total(class[best])) { best = i; } } printf("总分最高: %s\n", class[best].name); for (int i = 0; i < 3; i++) { if (class[i].chinese_score < 60.0 || class[i].math_score < 60.0 || class[i].english_score < 60.0) { printf("%s 有不及格科目\n", class[i].name); } } return 0; }这段代码里我特意写了一个total()函数，把“求总分”这个逻辑封装起来。你会发现，使用结构体的好处在这一刻完全体现出来了：想找总分最差的是不是也得把数组传进函数才行？让我再想想——其实这里是直接在main里访问class[i].name的，用点号访问成员，代码结构非常清晰。
3.3 结构体数组传给函数时的指针退化问题
结构体数组作为函数参数时，有一个非常容易踩坑的点：数组名会退化为指向第一个元素的指针。
void printStudents(struct Student class[], int n) { // 你以为这是“值传递”，函数里改class不影响外面？ // 实际上class退化为struct Student *指针，改的就是外面 class[0].id = 9999; }虽然函数形参看起来是数组形式，但C语言规定数组作为函数参数时，形参等价于指针，写struct Student class[]和写struct Student *class没有任何区别。也就是说，你在函数内部修改class[0]，外面数组的元素也会被改掉。
这既是一个坑，也是一个能力。如果你不想让函数修改原始数据，有两种办法：一是遍历时只读，不写；二是在调用时传数组的拷贝（成本高，不推荐）；三是用const修饰形参：
void printStudents(const struct Student class[], int n) { // 这时如果你尝试 class[0].id = 9999; 编译器会报错 }用const声明意图，让编译器帮你把关，这是在工程实践中非常值得养成的习惯。我看过很多代码，函数根本不改参数，但形参没加const，调用方看代码时无法判断这个函数会不会改掉自己的数据，非常难受。
4. 结构体的大小不是成员之和：内存对齐与sizeof实测
4.1 一个简单的char+int结构体，sizeof为什么不对劲
初学者第一次用sizeof测结构体大小，基本都会吓一跳。
#include <stdio.h> struct A { char c; int i; }; int main(void) { printf("%zu\n", sizeof(struct A)); // 大多数平台输出8，不是5 return 0; }按直觉，char占1字节，int占4字节，加起来5个字节。但sizeof(struct A)在32位和64位平台上通常是8，在某些情况下甚至是12。这是为什么？
答案是内存对齐，结构体不是把所有成员一个接一个地紧凑排列，中间有填充字节。
4.2 CPU读取内存的方式决定了对齐规则
现代CPU在读内存时，并不是按“1字节、1字节”那样任意取，而是按固定宽度的“字”（word）来读取。很多32位平台一个字是4字节，CPU从地址0、4、8、12等对齐位置读取内存填充总线是最快的。如果一个int变量的地址不是4的倍数，它可能跨越两个“字”，CPU就需要读两次甚至做额外拼接才能拿到完整数据。
内存对齐规则的简单表述如下：
- 每个成员变量的起始地址，必须是该成员自身对齐值的整数倍。
- 结构体自身的对齐值，取“所有成员中最大的对齐值”。
- 结构体总大小必须是结构体自身对齐值的整数倍。
在主流x86平台上，char对齐值为1，short对齐值为2，int对齐值为4，float对齐值为4，double对齐值为8。比如struct A里第一个成员的地址等于结构体首地址，所以char c天然对齐到1；接着要放int i，int要求地址是4的倍数，而char后面只过了1个字节，从1到4之间还需要补3个字节，于是编译器在c后面塞了3个填充字节，i从偏移4开始存放。结构体总大小为1+3+4=8，正好是4的倍数。
4.3 手工计算结构体尺寸的通用步骤
你会手工算了，以后看别人的结构体定义，心里就能快速估算它的内存开销。
计算步骤分三步：
- 从首地址0开始，按成员定义顺序，累加每个成员的实际占用字节。
- 每放一个成员前，检查当前偏移是否是该成员对齐值的整数倍，不是则向后填充到满足为止。
- 全部放完后，如果总大小不是“结构体最大对齐值”的整数倍，再补到符合要求。
我用一个例子演示：
struct B { char c1; // 偏移0，占1字节 int i; // 要求对齐4，当前偏移1，补3字节，放到偏移4，占4字节 char c2; // 要求对齐1，当前偏移8，放偏移8，占1字节 };走到最后，当前偏移9，结构体最大对齐值是4，所以必须补到12。sizeof(struct B) = 12。
如果把成员顺序调整成这样：
struct C { int i; // 偏移0，占4字节 char c1; // 偏移4，占1字节 char c2; // 偏移5，占1字节 };最后偏移6，最大对齐值4，补到8。sizeof(struct C) = 8。
同样的两个char一个int，排列顺序不同，结构体大小从12降到8。在数组场景下差异更明显：一个10000个元素的数组，每个元素省4字节，省下来的内存就是可观的。所以定义结构体时，把占用空间大的成员往前放，把小的聚在一起，能明显压缩结构体体积。
4.4 调整成员顺序与强制紧凑布局的取舍
手动调整成员顺序确实能省内存，但前提是不要破坏成员之间的逻辑关系。我见过有的代码为了省那4字节，把结构体成员顺序改得乱七八糟，导致阅读者一对一对字段找，可读性反而变得很差。我的建议是：先按业务逻辑排列，如果确实需要优化，再调整顺序，并在注释里说明调整原因。
还有一种情况需要强行取消对齐：网络协议报文解析、文件格式读写、硬件寄存器映射。这些场景要求结构体成员必须按字节连续排列，不能有填充，否则你从网络收到的数据直接强转成结构体指针时，成员就会错位。
强制紧凑布局的方式依编译器而定：
#pragma pack(1) struct Packet { uint8_t version; uint16_t length; uint32_t seq; }; #pragma pack()gcc还支持在类型定义前加属性：
struct Packet { uint8_t version; uint16_t length; uint32_t seq; } __attribute__((packed));但你必须明白，紧凑布局牺牲的是访问性能，未对齐的成员在某些平台（比如一些ARM处理器）上甚至会导致总线错误。嵌入式开发里用packed处理协议头是常规操作，但在通用应用软件里不建议随便pack，普通开发场景默认对齐反而更稳。
5. 结构体指针：传参、修改与动态结构
5.1 按值传参的隐藏开销与限制
结构体变量可以整体赋值，所以自然可以整体传给函数，这是它和数组最大的区别。看看这个例子：
void printStudent(struct Student s) { printf("%s %d\n", s.name, s.id); }调用时，编译器会把整个struct Student结构体按值拷贝一份到函数栈空间。如果结构体不大，比如只有几个int和char，这种拷贝基本没影响。但如果你的结构体里有大数组，比如：
struct Account { char username[512]; char password_hash[64]; long last_login; int flags; };按值传一次，就要在栈上复制几百字节，频繁调用就会明显拖慢性能，甚至撑爆栈空间。而且函数内部修改形参s，外面的原始变量完全不受影响，因为这就是两个不同的内存区域。
这时候你需要结构体指针。
5.2 结构体指针的访问语法：(*p).field 与 p->field
声明方式很简单：
struct Student stu; struct Student *p = &stu;通过指针访问成员，有两种写法。第一种是解引用后取成员：
(*p).id = 2024005;注意括号不能省略，因为优先级上点号比星号高，你写p.id会被解析成(p.id)，含义完全不对。
第二种是箭头操作符，这是C语言专门为结构体指针设计的语法糖：
p->id = 2024005;p->id等价于(*p).id。箭头操作符可读性高得多，工程代码里几乎都是用箭头来添加。这里的优先级也值得记住：p->id比p->id++的解析更好，它表示先取id的值再自增；但如果你想自增的是指针本身，得写p++或者++p，写法上要小心区分。
5.3 用指针在函数内部修改结构体的完整过程
如果要写一个函数修改学生的某科成绩，你脑子里应该立刻有两条路：
第一个是传值，无法修改外面的变量：
void updateScore(struct Student s, float newScore) { s.math_score = newScore; // 只改了形参的副本 }第二个是传指针，直接操作原结构体：
void updateScore(struct Student *s, float newScore) { s->math_score = newScore; // 外层同名字段的原始值被修改 }调用时，分别这样写：
updateScore(stu, 99.0); // 无效，stu没变 updateScore(&stu, 99.0); // 有效，stu.math_score被改成99.0这是结构体指针最重要的用途之一：通过指针参数，在函数内部修改调用方的数据。C语言所有参数默认都是值传递，只有把地址传进来，函数才能通过地址找到原始内存位置进行修改。
如果你想让某个结构体被多个函数共享并维护状态，就直接把指针传来传去。
5.4 动态分配结构体与链表节点的基本形态
不靠全局变量能在堆上创建结构体吗？当然可以，malloc即可：
struct Student *stu = (struct Student *)malloc(sizeof(struct Student)); if (stu == NULL) { // 处理分配失败 exit(1); } strcpy(stu->name, "Bob"); stu->id = 2024006; free(stu);malloc括号里一定要写sizeof(struct Student)，不是sizeof(struct Student *)，后者只是指针本身的大小，分配出来的内存根本放不下一个结构体。
结构体指针还是实现链表、二叉树等动态数据结构的基础。链表节点的定义长这样：
struct Node { int data; struct Node *next; };next是一个指向本结构体类型的指针，通过这个指针，节点之间串成链，就可以动态增删。这种“结构体指针”的组合是C语言数据结构的灵魂，也是后面学数据结构的必经之路。
6. 嵌套结构体、typedef与自引用：工程化改造结构体
6.1 嵌套结构体的定义与访问方式
结构体成员可以是另一个结构体变量，这在工程里非常常见。比如给每个学生增加“入学日期”和“出生日期”，可以先定义日期结构体，再把它嵌到学生结构体里：
struct Date { int year; int month; int day; }; struct Student { char name[20]; struct Date birthday; struct Date enroll_date; };访问嵌套成员时，只需要连续用点号：
stu.birthday.year = 2005; printf("%d-%d-%d\n", stu.birthday.year, stu.birthday.month, stu.birthday.day);用指针访问时，箭头和点号混用：
struct Student *p = &stu; p->birthday.year = 2005;这里p->birthday.year的意思是：通过p找到birthday这个结构体成员，再取birthday里的year。读起来特别顺，层次关系一目了然。
如果成员内部还有结构体，嵌套层级也不建议过深，一般两到三层就打个头。超过三层，代码阅读成本会爆炸，你应该考虑把一个多层结构体拆成两个扁平结构体，或者干脆拆成另一个类型。
6.2 typedef struct的常见写法与命名习惯
每写一次struct Student都非常啰嗦，C程序员喜欢用typedef缩短它：
typedef struct Student { char name[20]; int id; } Student;这行代码做的事情是：定义struct Student类型，同时给struct Student起了个别名Student。此后你写Student stu;就行，不需要再写struct。
还有一种更省事的写法是直接使用匿名结构体配合typedef：
typedef struct { char name[20]; int id; } Student;这个写法定义出来的类型也有成员，但没有struct标签，只能用Student这个别名。这样写的好处更简短，坏处是遇到自引用时不能直接用类型名来声明成员指针（后面会讲），你必须回到带标签的写法。
至于命名习惯，我建议你是大驼峰还是下划线都行，关键是统一。Windows风格常写typedef struct _Student { ... } Student;这是把标签名和类型名故意分开，目的是避免和类型名冲突。我的建议是如果你不希望在同文件里处理tag和类型名两套命名，直接用typedef和匿名结构体其实最舒服，不过自引用的场景除外。
6.3 结构体不能直接包含自身，但可以包含指向自身的指针
新手最容易巴的地方在这里。他们写的链表节点很可能长得像：
struct Node { int data; struct Node next; // 编译错误 };为什么错？你思考一下：Node里面有一个Node，这个Node里又有一个Node，无限递归下去，结构体的大小永远算不出来，编译器无法为它分配确定长度的内存。
但写成指针就没问题：
struct Node { int data; struct Node *next; // 指针的大小是固定的，4或8字节 };指针的大小是固定的，所以编译器能算出来。这就是为什么链表、树之类递归结构在C语言里一定要用指针自引用的原因。
另外注意，如果用了匿名结构体配合typedef：
typedef struct { int data; Node *next; // 错误：此时Node这个类型名还没定义完，编译器不认识Node } Node;匿名结构体在定义中无法引用自身的别名。你需要往回收，使用带标签的写法：
typedef struct Node { int data; struct Node *next; } Node;这里struct Node这个标签在定义内部就是完整的，可以被自己引用，而后面再To别名Node。这种写法是链表的标准形态，一定要背熟。
7. 结构体使用中容易踩的坑与排查思路
7.1 空指针访问成员：最容易踩的崩溃
结构体指针在使用前如果不判空，一访问成员就会段错误。尤其在链表遍历时：
struct Node *p = head; while (p != NULL) { printf("%d\n", p->data); p = p->next; }这里条件p != NULL必须写，否则遍历到尾部会访问NULL->data，直接崩溃。这类错误排查起来又常常隐蔽，因为崩溃点往往不在代码出错的那一行，而在程序真正访问那行代码又很久之后。
我的建议是：只要是外部传入的结构体指针，一律先判NULL。尤其写函数时，参数是结构体指针就必须明确这个函数允不允许传入NULL；如果不允许，就加断言或判断，在入口挡一道：
void updateScore(struct Student *s, float newScore) { if (s == NULL) { return; } s->math_score = newScore; }7.2 赋值与比较的误区：整体赋值可以，==比较不行
结构体整体赋值是允许的，st2 = st1是把st1的内存原样拷贝过去。但它的两个结构体之间不能使用==比较，编译器会直接报错。别指望某种新标准会突然放开这个限制，C标准至今仍把结构体比较限制为只允许用memcmp或逐成员比较。
所以处理方式有两种冗余：
第一种，逐成员比较，适合成员数量少：
int studentEqual(struct Student a, struct Student b) { return strcmp(a.name, b.name) == 0 && a.id == b.id && a.chinese_score == b.chinese_score && a.math_score == b.math_score && a.english_score == b.english_score; }第二种，使用memcmp，但需要注意，memcmp会连填充字节也比较，如果两个结构体的填充字节不同，即使所有成员值都一样，memcmp也可能返回非零，导致误判。因此，用memcmp比较结构体时需要先对结构体做memset清零，保证填充字节是确定的。我自己的习惯是选逐成员比较，过程不复杂，而且遇到浮点数还能用允许误差的比较法，更加可靠。
7.3 结构体释放后继续使用：悬空指针问题
动态分配的堆空间，如果free之后再使用，就产生了悬空指针：
struct Student *s = malloc(sizeof(struct Student)); free(s); s->id = 5; // 未定义行为，大概率崩溃free之后，指针s本身并不会变成NULL，它依然保存着数组地址，这段地址可能已经被系统回收或分配给别的数据，继续读写就是访问非法内存。这类问题在大型程序中特别难复现，因为它跑一次正常，换一次数据或换个环境就崩溃。
规避办法有两条：
- free之后把指针置成NULL，这样如果再访问，至少会以段错误的形式暴露问题，而不是悄悄的非法数据。
- 配合“谁分配谁释放”原则，避免多个函数交叉持有同一块结构体内存，谁也不敢保证别人什么时候释放了它。
排查悬空指针问题时，最有效的手段是开地址消毒器（AddressSanitizer），gcc/clang加-fsanitize=address编译，它会直接在有问题的read/write现场报告非法访问。这是我现在调试C内存问题必用的手段，比对着源代码猜半天快得多。
写在最后：我这些年用结构体的体会
如果说C语言是一把瑞士军刀，那结构体就是那个让你能自定义刀片形状的模具。它把零散变量收纳成对象，让代码从“对着变量打架”变成“对着对象思考”，这是C语言里最接近“面向对象思想”的一层能力，也是在为后续学链表、树、队列打基础。
我个人体会到的最重要经验是：结构体定义不该迁就当前需求随便写，而应该当成一种“数据契约”来设计。团队成员看到这个结构体，就知道整个系统里数据长什么形状、边界在哪里。多用const修饰形参、多用typedef统一类型名、多按对齐规则优化布局，这三个习惯比多写几个结构体重要得多。
如果你正要开始做C语言里的第一个综合项目，我建议就从结构体数组开始，尝试写一个带增删改查的学生成绩管理，或者图书库存管理。你会发现，用上结构体之后，很多原来想不明白的数据组织思路会突然一下子清晰起来。
