不知道你注意到没有，学 C 语言到数组这一章，一切还算顺风顺水：一维数组、二维数组，无非是往箱子里塞数据。可一旦碰到"学生信息管理"这类题目，很多人就懵了——一个人身上有姓名、学号、成绩、年龄、性别，数据类型完全不一样，数组根本装不下。卡在这个位置三五天是常事，最后解决问题的统一方案，都是同一个词：结构体。
嘎嘎滴辣虾这个网名看着有点不正经，但标题里"自定义类型——结构体"这几个字，翻译成大白话其实就是：C 语言允许你自己造一种新的数据类型，把一堆不同类型的数据捆在一起。这篇我就把这个事讲透，从"为什么要搞这种东西"到"怎么用最顺手"，再到哪些地方容易踩坑，一条龙说清楚。新手可以照着练，已经写过结构体但总出错的人也能对号入座找原因。
1. 数组装不下的事情：从"散装变量"到"打包数据"
1.1 一个学生到底需要几个变量
先回到最原始的出发点。假设你要写一个最最简单的学生成绩管理系统，一个学生，就一个，包含如下信息：
- 姓名：字符串，C 语言里用字符数组存
- 学号：整数
- 成绩：小数
不用结构体的话，你只能写三个变量：
char name[20]; int num; float score;然后呢？然后这个"学生"就不存在了。因为这三个东西之间没有任何绑定关系，你只拥有三个独立的、互不相干的变量。系统里如果有 50 个学生，那就得写 150 个变量，命名会变成name0, num0, score0, name1, num1...这种灾难现场，写到一半自己都想删代码。
数组能解决一部分问题——如果你只要存 50 个学号，一个int num[50]就搞定。但问题是学生的属性不只一个，姓名是字符数组、成绩是浮点数，它们的类型、长度、意义各不一样，没法放进同一个数组里。
这就是结构体的出生场景：把"一个对象"的多维度属性聚合成一个整体，让数据之间产生归属关系。
1.2 结构体的本质：自己造一个类型
C 语言自带的基本类型就那几个：int、float、char、double，这是娘胎里带的。而结构体的玩法相当于你可以自己发明一个新类型：
struct Student { char name[20]; int num; float score; };写完之后，struct Student就变成了一个和int平起平坐的类型名。你可以用它声明变量：
struct Student stu1; struct Student stu2;每一个stu内部都自带name、num、score三个成员。说人话，就是你先画了一张"学生模板"的图纸，然后按这个图纸生产出多个学生实例。图纸本身不占内存，生产出来的实例才占内存。
这个思想在别的语言里也会有对应物，比如 Java/C++ 的类、Python 的字典和类、Go 的 struct，核心思路都是一样的。C 语言里的结构体是最朴素的那版容器，它没有方法、没有访问权限修饰符，就只有数据打包。
提示：基础不牢的读者请记住这句话——
struct Student是类型，就像int是类型；stu1是变量，就像a是变量。类型不占内存空间，变量才占。
1.3 为什么不能直接用二维数组代替
有人可能会动这个念头：姓名一个二维数组，学号一个一维数组，成绩一个一维数组，三个数组不就装下了？能用，但这不是"学生管理系统"，这是三个平行的数据表格，彼此之间全靠下标"心照不宣"地对应着。
今天你给第三个学生的成绩改成 90 分，得先想清楚score[2]和name[2]、num[2]是绑一起的。但下标不会给你任何提示，你只能靠管理纪律约束自己。一旦发生插入、删除、排序操作，三个数组要同步调整，漏一个就是数据错位。
结构体的价值在这里就体现得非常充分：排序的时候把整个结构体变量来回搬，姓名学号成绩永远是一体的，不存在"搬了成绩忘了搬姓名"的破事。所以结构体不是锦上添花，是数据量一上来就变成刚需。
2. 结构体的定义与初始化：先把语法坑排干净
2.1 定义结构体：末尾分号是第一个大坑
定义结构体的位置一般在main函数外面，也可以在函数里面，位置不同作用域不同：
- 写在所有函数外面：全局类型，所有函数都能用
- 写在某个函数内部：局部类型，只有这个函数能用，实际开发基本不这么干
标准写法如下，注意末尾的分号：
struct Student { char name[20]; int num; float score; }; // 这个分号！没有它编译直接报错初学者最容易犯的错，就是抄代码漏掉这个分号，然后编译器报一长串看不懂的错。报错的位置还不一定指向分号那一行，而是指向下一个正常代码行，非常劝退。
另一个常见错误是搞混类型名和变量名：
struct Student { char name[20]; int num; float score; }; Student stu1; // 错误：C语言里必须写 struct Student在 C 语言里，结构体类型名的正规叫法必须带struct前缀。这点跟 C++ 不一样，C++ 里可以直接写Student stu1;，但纯 C 环境下这么写编译直接挂。想去掉struct前缀，得用typedef偷懒，后面专门讲。
2.2 三种初始化方式：动手之前先想清楚
方式一：声明时直接按成员顺序给初值，最省事：
struct Student stu1 = {"小明", 10001, 88.5};注意顺序不能乱，必须和结构体里成员的声明顺序完全一致：先姓名，再学号，最后成绩。写成{10001, "小明", 88.5}编译大概率只报一个警告，但运行起来就乱了。
方式二：指定成员名初始化，C99 标准开始支持，顺序可以打乱，可读性更好：
struct Student stu1 = { .score = 88.5, .name = "小明", .num = 10001 };这种方式配合比较复杂的结构体特别好使，不用一个个数成员顺序，代码自解释能力很强。
方式三：先声明变量，再逐个赋值：
struct Student stu1; strcpy(stu1.name, "小明"); // 字符串不能直接赋值，必须用 strcpy stu1.num = 10001; stu1.score = 88.5;这里有一个 C 语言字符串的老毛病：结构体成员是字符数组时，不能用stu1.name = "小明"这种写法直接赋值，必须用strcpy。这个坑几乎人人踩过，不是结构体的逻辑问题，是 C 语言数组的赋值规则就这个德性。
2.3 成员访问：一个点走天下
访问结构体成员用点运算符：
printf("姓名：%s，学号：%d，成绩：%.1f\n", stu1.name, stu1.num, stu1.score); stu1.score = 95.0; // 直接修改成员点运算符的优先级非常高，绝大多数情况下不需要加括号。唯一的注意事项是，如果结构体变量本身又是一个更大结构体的成员，那访问路径就是"层层深入"，比如后面要讲的student.birthday.year这种。
提示：
struct Student stu1是栈上分配的内存，成员的值都存在这块连续内存里。点运算符本质就是"找到结构体变量起始地址，再按成员类型的长度偏移到目标位置"，理解这个，后面学指针就顺了。
3. 处理一堆对象：结构体数组才是真正的战场
3.1 从一个学生到一个班
单条结构体变量解决的是"一个学生的数据建模"，但实战项目里永远是一堆学生、一堆商品、一堆订单。这就需要结构体数组，把"某种类型的一批数据"组织起来：
struct Student class1[50]; // 一个班50个学生这就相当于在栈上分配了 50 个一模一样的结构体变量，连续排列成数组。访问方式和普通结构体变量几乎一样，只是多了一层下标：
strcpy(class1[0].name, "小红"); class1[0].num = 10002; class1[0].score = 91.0;配合循环，批量初始化就来了：
for (int i = 0; i < 50; i++) { class1[i].num = i + 1; class1[i].score = 0.0f; }这种写法在处理固定数量对象时是最优解。你可以把它想象成 Excel 表格：一列是一个学生，一行是一个字段，下标就是行号，字段名就是列名，比散装变量不知道规整到哪里去了。
3.2 用循环打印所有学生
下面这个例子可以完整跑起来，逻辑就是一个班 3 个学生的成绩遍历：
#include <stdio.h> #include <string.h> struct Student { char name[20]; int num; float score; }; int main(void) { struct Student class1[3] = { {"小明", 10001, 88.5}, {"小红", 10002, 91.0}, {"小刚", 10003, 76.5} }; for (int i = 0; i < 3; i++) { printf("姓名：%s 学号：%d 成绩：%.1f\n", class1[i].name, class1[i].num, class1[i].score); } return 0; }输出的结果就是三行整齐的学生信息。我第一次看到这种写法时最大的感觉是"原来数据可以这么规整"，心里的成就感还是不小的。
3.3 结构体数组的排序：整体搬，别只搬一个字段
结构体数组最大的优势在排序时体现出来。按成绩排序，传统数组做法是交换两个int，而结构体数组做法是直接交换两个struct Student变量：
struct Student tmp; tmp = class1[i]; class1[i] = class1[j]; class1[j] = tmp;这一交换，姓名、学号、成绩全部跟着走，因为它们在内存里本来就是一体打包的。你不需要手写 "交换姓名，交换学号，交换成绩" 三行操作，C 语言里结构体变量可以直接整体赋值。
这一点务必记住：结构体变量之间可以用=直接赋值，这是合法的，系统会自动把 A 变量的所有成员逐字节复制给 B。注意这只是浅拷贝，如果结构体里面有指针成员，那赋值的只是指针本身，指向的对象还是同一个，很多人栽在这个上面，后面详细说。
4. 结构体指针：用"箭头"操作数据的正确姿势
4.1 为什么要碰指针
数组规模一大，函数之间传递结构体就变成一个问题。如果你把整个结构体当作参数扔给函数，C 语言默认会拷贝一份完整的数据进去，50 个成员就拷贝 50 份，性能开销肉眼可见的大。
更麻烦的是，值拷贝进去之后，你在函数里改的是副本，外面的原始数据纹丝不动。很多新手在这里栽跟头：写了个更新成绩的函数，调用了半天，main 里面打印成绩还是老样子。
所以结构体的精髓操作，是配合指针来玩的。
4.2 结构体指针的定义与两写法
定义一个指向结构体的指针，跟定义指向基本类型的指针逻辑完全一样：
struct Student stu1 = {"小明", 10001, 88.5}; struct Student *p = &stu1;p存的是stu1的地址。要访问p所指向结构体的成员，有且仅有两种等价写法：
(*p).score = 95.0; p->score = 95.0;第一种写法先把p解引用得到结构体变量，再用点运算符找成员。因为*p的优先级低于.，所以必须加括号，写多了手酸、眼也花。
第二种写法用->箭头运算符，这是编译器的内置糖，专门为结构体指针设计的，一举搞定"解引用加取成员"两步操作。实际开发中你看到的所有p->xxx，本质就是先拿到指针指向的结构体，再取它的字段。
提示：什么时候用点、什么时候用箭头，就一条判断规则——左边是结构体变量就用
.，左边是结构体指针就用->。p->score是"指针指向的结构体里面的 score"，stu1.score是"变量 stu1 里面的 score"，别想复杂了。
4.3 数组名在参数传递中的陷阱
结构体数组当参数传递时，数组名会自动退化成指针。所以函数形参可以这么写：
void printClass(struct Student class1[], int n) { for (int i = 0; i < n; i++) { printf("%s %d %.1f\n", class1[i].name, class1[i].num, class1[i].score); } }实际上这里的class1[]在编译器眼里就是struct Student *，你在函数里用class1[i]改数据，改的就是外面那个数组的元素，因为传进来的是首地址，不是拷贝副本。
这算是一个"隐性指针"，新手可能没意识到，但行为确实如此——数组传参天生就是引用传递，和普通变量传参不同。理解了这一点，你就知道为什么函数里改数组元素会直接影响到 main 里的原数组。
4.4 结构体自引用与链表的入口
结构体指针还有一个高阶玩法，就是结构体里面包含一个指向自身类型的指针。这是链表、二叉树等一切动态数据结构的基石：
struct Node { int data; struct Node *next; };每个节点除了存自己的数据，还存着下一个节点的地址，就这样一个扣一个串成链表。没有结构体指针，这些东西全都玩不转。这也是"嘎嘎滴辣虾"这种学习笔记里，结构体永远排在链表前面的原因——不打好这个底，后面更难的数据结构全都没法学。
5. 嵌套结构体与 typedef：让数据模型真正立起来
5.1 结构体套结构体：把信息分层
现实世界的数据总有层级关系。比如一个学生的出生日期，本身由年、月、日三个字段组成，你当然可以拍平了写：
struct Student { char name[20]; int birthYear; int birthMonth; int birthDay; int num; float score; };没毛病，但一旦字段多了，这结构体里全是平平铺开的字段，可读性直线下降。更合理的做法是先定义一个日期结构体，再嵌入到学生结构体里：
struct Date { int year; int month; int day; }; struct Student { char name[20]; struct Date birthday; // 结构体成员 int num; float score; };访问嵌套成员的路径是一层一层走下去的：
struct Student stu1 = {"小明", {2002, 5, 20}, 10001, 88.5}; printf("%d年%d月%d日\n", stu1.birthday.year, stu1.birthday.month, stu1.birthday.day); stu1.birthday.year = 2001; // 直接改嵌套成员的字段这里的逻辑和文件路径很像：stu1是根目录，birthday是一级文件夹，year是二级文件。层次感出来了，代码读起来就跟自然语言一样清晰。
嵌套结构体的深度其实没有硬性限制，你可以继续套继续套，但实际项目中套到两层就够了。套到三层以上，每层访问都写一长串点，代码脆且难维护，属于给后来人埋雷。
5.2 typedef 改名：告别 struct 前缀
用struct Student写变量名每次都要打六个字母的struct，写多了烦。C 语言提供了typedef关键字给类型起别名，相当于给人起绰号：
typedef struct Student Student;写完这句之后，后面声明变量就可以直接写：
Student stu1; Student class1[50];省略struct前缀，代码瞬间清爽。更狠的是可以把定义和改名合并到一起：
typedef struct { char name[20]; int num; float score; } Student;这个写法的意思是：定义一个匿名的结构体类型，同时给它起名为Student。以后直接用Student声明变量，名称自带，干净利落。这是初学者最接近实战习惯的写法，在很多开源项目里都能看到这种风格。
注意：匿名结构体配合 typedef 虽然方便，但如果结构体要自引用，比如链表节点里包含
next指针，就不能用匿名 typedef 直接搞，因为别名在定义完成之后才生效。这时必须写成非匿名形式：
typedef struct Node { int data; struct Node *next; } Node;里面那个struct Node *next;才是合法的自引用写法。
5.3 typedef 名称命名规范建议
给结构体起别名时，行业里比较通用的做法是首字母大写，比如Student、OrderInfo、ProductItem。这样在代码里一眼就能和普通变量区分开。
也有人习惯在结构体变量名后加_t后缀，比如student_t，这是老派 Unix 风格，在一些系统级 C 代码里很常见。两种风格都行，关键是整个项目保持一致，别一会儿Student一会儿student_t，看着头疼。
6. 函数传参的两种姿势：值传递和指针传递怎么选
6.1 传整个结构体进去：简单但费钱
把结构体当普通参数传，函数接收的是副本：
void printStudent(struct Student s) { printf("姓名：%s 学号：%d 成绩：%.1f\n", s.name, s.num, s.score); }调用是这么来的：
printStudent(stu1);这里发生了一次完整拷贝：stu1的所有成员逐字节复制给形参s。如果结构体很大（比如里面有个 1000 字节的字符数组），拷贝开销就是一整块内存复制。不过对于小型结构体、打印查看这种只读操作，这个写法最直观，性能损失也完全可以忽略。
但有一个点必须明确：在printStudent里给s.score改成任何值，外面的stu1纹丝不动。它们只是长得一样，内存完全独立。
6.2 传指针进去：能改原数据，但注意加 const
使用指针传递的意义就是两个方面：省拷贝、能修改原数据。
void updateScore(struct Student *p, float newScore) { p->score = newScore; }调用：
updateScore(&stu1, 95.0); printf("%.1f\n", stu1.score); // 输出 95.0这一次修改是真的改在stu1身上。但问题来了：指针传进去，意味着函数内部有完全的操作权限，它不但能改成绩，还能改姓名、学号，甚至把整个结构体抡圆了改。有些情况下我们只想传址省内存、不想函数内部动数据，那就该加const锁住：
void printStudent(const struct Student *p) { // 能读，能传得高效，但 p->score = 0 这种写法会编译报错 printf("姓名：%s 学号：%d 成绩：%.1f\n", p->name, p->num, p->score); }const struct Student *的意思是：p指向的东西是只读的，函数里任何尝试修改成员的代码都会被编译器拦下来。这相当于给函数加了一道安全护栏，同时保留了传指针的高效性，官方推荐做法。
我个人的选择经验就三条：
- 只读、结构体大：用
const struct Student * - 要修改原数据：用
struct Student * - 结构体很小、就是打印一下：值传递也无妨，代码最简洁
6.3 函数返回结构体：可行但别高频用
函数也可以直接返回一个结构体：
struct Student createStudent(void) { struct Student s; strcpy(s.name, "新人"); s.num = 10000; s.score = 0.0f; return s; }调用时依然会发生拷贝，把临时结构体的内容复制给外部变量。小结构体随便用，但如果你在一个大循环里高频调用这种函数，拷贝开销会被放大。这时候更通用的做法是让调用方传入指针，函数内部填充：
void initStudent(struct Student *p, const char *name, int num, float score) { strcpy(p->name, name); p->num = num; p->score = score; }这算是"输出参数"模式，在嵌入式 C、系统级 C 代码里极其常见。效率最高的同时，也让函数职责更清晰——这个函数只管往用户提供的内存里填数据，不负责分配内存，内存生命周期由调用方控制。
7. 我替你们踩过的坑：结构体实战避坑指南
7.1 结构体变量不能直接用 == 比较
两个结构体变量不能直接用==判断是否相等：
struct Student a = {"小明", 10001, 88.5}; struct Student b = {"小明", 10001, 88.5}; if (a == b) { // 编译报错！ // ... }C 语言没给结构体定义"相等"的语义，编译器根本不知道你要拿哪个字段做比较。对比时需要一个个成员去比：
if (strcmp(a.name, b.name) == 0 && a.num == b.num && a.score == b.score) { // ... }有些人会说不对，我用memcmp(&a, &b, sizeof(a))行不行？理论上可以，但前提是结构体里没有内存对齐产生的"空洞字节"。这些空洞位置的值是不确定的，两个内容看起来一模一样的结构体，空洞字节可能不同，memcmp照样告诉你"不相等"。所以老老实实逐成员比较，这是最稳妥的做法。
7.2 结构体里放指针成员时的浅拷贝陷阱
结构体可以整体赋值，其实质是浅拷贝：
struct Student { char name[20]; int *scores; // 指向一个动态数组 };把 a 赋值给 b：
b = a;表面上是把 a 的所有成员复制给 b，但b.scores和a.scores指向的是同一块动态内存。你通过b.scores改数据，a 那边也跟着变。这不算错，但你必须清楚这是"共享底层数据"，不是"复制了一份独立的新数据"。如果 b 和 a 应该拥有各自独立的数组，那就必须手动分配内存再逐元素复制，这就是深拷贝。
7.3 结构体大小不是成员之和：内存对齐
用一个最经典的例子：
struct Example { char c; // 1 字节 int i; // 4 字节 };你猜sizeof(struct Example)是多少？直觉告诉我是 5，实际通常是 8。因为 CPU 在读取内存时按 4 字节为单位效率最高，编译器会在c后面填充 3 个字节的空白，让i的起始地址对齐到 4 的倍数。这就是内存对齐。
这个知识点平时不用管，但当你用结构体做底层协议解析、文件读写、网络发包时，必须清楚结构体在内存里的真实布局和成员顺序有关系。不同成员排列顺序不同，结构体总大小也会不同。想深入了解就搜索"结构体对齐规则"，这里不展开，知道有这回事，排查 bug 时不至于抓瞎。
7.4 字符串成员永远用 strcpy
任何情况下，结构体里字符数组成员都不能直接赋值：
strcpy(stu1.name, "小明"); // 对 stu1.name = "小明"; // 编译报错后者在 C 语言里是非法的，因为name是数组，数组名是地址常量，不能重新指向别的字符串字面量。如果结构体里用的是char *name指针成员，那倒是可以直接stu.name = "小明"，但那是把指针指向一个字符串字面量，属于完全不同的内存管理方式，可别混为一谈。
7.5 别一股脑把所有字段全塞进一个结构体
最后补充一个设计层面的建议。结构体的粒度要合适，不是字段越多越好。一个订单结构体塞 30 个字段，里面有十几项其实是独立的子信息，那设计上就出了大问题。
正确做法是把高内聚的子信息拆成独立结构体，再嵌套组合。比如用户信息拆成BasicInfo、ContactInfo，订单里只嵌套这两个结构体。这样代码可读性高，后面维护也知道去哪找字段，而不是在一个 30 字段的大结构体里翻半天。
说到底，结构体就是你给现实世界的对象建模的工具。建得好，代码跟记流水账一样清晰；建得差，后面重构的时候只想删库跑路。
我自己的学习路径是这样的：先拿最简单的大学生选课系统练手——学生结构体、课程结构体、选课关系用两个结构体数组模拟，搞定增删改查，输出各种统计报表。这套练完，什么结构体数组、指针、嵌套、传参，所有坑都踩得差不多了。练的时候别抄网上的完整代码，先自己设计字段，再自己写初始化、写排序、写查找，写完再去跟经典实现对比，缺啥补啥。这个过程走一遍，比看十篇教程都管用。
