Struct到底是什么？
在C语言开发中，struct(结构体)是最基础也最灵活的语法特性之一。几乎每个C语言开发者都会用struct定义自定义数据类型，但大多数人只停留在“把不同类型变量打包”的基础用法上，很少深挖它能玩出多少花样。实际上，从数据封装到面向对象模拟，从内存优化到底层驱动开发，struct的巧妙用法能帮我们解决很多复杂问题，写出更简洁、更高效、更易维护的代码。今天我们就从基础出发，一步步探索struct那些你可能不知道的高级用法。
一、基础回顾：struct到底是什么?
首先我们快速回顾一下struct的核心定义：struct是一种用户自定义的数据类型，允许我们把多个不同类型(也可以相同类型)的数据组合在一起，形成一个新的复合类型。比如我们要描述一个学生的信息，包含姓名、年龄、成绩三个属性，用struct定义就是：
struct Student {
char name;
int age;
float score;
};
这样我们就得到了一个新的struct Student类型，可以像普通类型一样定义变量：
struct Student stu1; // 定义一个学生变量
struct Student stu_arr; // 定义一个存放10个学生的数组
和普通数组相比，struct最大的优势就是可以把不同类型的数据逻辑上组合在一起，让代码更清晰——一个学生的所有信息都打包在一个变量里，传递的时候直接传结构体指针就可以，不需要分别传递多个参数，代码可读性大幅提升。这是struct最基础的用法，但它的能力远不止于此。
二、进阶用法：藏在标准语法里的实用技巧
很多高级用法其实都是基于标准语法衍生出来的，只是很多开发者没有注意到，我们一个个来看：
1. 结构体嵌套：分层封装复杂数据
对于复杂的业务场景，一个结构体里还可以嵌套另一个结构体，实现分层封装，让数据结构更清晰。比如我们要描述一个班级，班级里有多个学生，还包含班主任信息，可以这么写：
struct Teacher {
char name;
int age;
};
struct Class {
struct Teacher head_teacher;
struct Student students;
int student_count;
};
这样分层封装之后，数据关系非常清晰，class.head_teacher.name就能直接拿到班主任姓名，不需要把所有字段都堆在一个结构体里，代码逻辑和实际业务关系完全对应，维护起来非常方便。
嵌套结构体最常用的场景是链表和树，经典的链表节点定义就是用结构体嵌套指针：
struct Node {
int data;
struct Node *next; // 嵌套指向同类型结构体的指针
};
这也是利用struct特性实现复杂数据结构最经典的写法。
2. 柔性数组：灵活分配内存的利器
C99标准之后，struct允许结构体最后一个成员是大小未知的数组，这就是柔性数组，是动态分配结构体非常好用的技巧。比如我们要做一个动态变长的缓冲区，传统写法是：
// 传统写法，指针单独分配，两次申请内存
struct Buffer {
int len;
int *data;
};
这种写法需要先分配struct Buffer，再给data分配内存，释放的时候也要分两次释放，很麻烦，还容易产生内存碎片。用柔性数组可以改成：
// 柔性数组写法
struct Buffer {
int len;
int data[]; // 柔性数组成员，不占用struct大小
};
分配的时候一次性分配好所有内存：
// 需要长度为n的缓冲区，一次性分配：struct大小 + n * int大小
struct Buffer *buf = malloc(sizeof(struct Buffer) + n * sizeof(int));
buf->len = n;
整个缓冲区只需要一次分配，释放的时候一次free就搞定，不仅语法简洁，还减少了内存碎片，访问速度也更快，因为数据和结构体头部连续存放，缓存命中率更高。这是嵌入式开发里做动态缓冲区非常常用的技巧。
注意：柔性数组只能放在结构体最后一个位置，前面必须有至少一个其他成员，这是标准规定的用法。
3. 位域：精准压缩内存空间
当我们需要处理一些按位存储的信息，比如状态标志、硬件寄存器的时候，用普通变量会浪费很多空间，struct的位域特性可以让我们按位指定每个成员占用的空间，极大压缩内存。比如我们要存储三个状态标志，每个只需要1位，用普通int要占12字节，用位域只需要4字节(甚至可以压缩到2字节)：
struct Status {
unsigned int flag1 : 1; // 占用1位
unsigned int flag2 : 1; // 占用1位
unsigned int flag3 : 1; // 占用1位
unsigned int value : 4; // 占用4位，最大存15
};
这个结构体总共才占用7位，编译器会自动把它们打包到一个int里，总共只占4字节，比分开定义三个int节省了三分之二的空间，在资源紧张的嵌入式领域非常有用。驱动开发里描述硬件寄存器的时候，位域更是标准用法：可以直接把寄存器每个位对应到结构体成员，读写寄存器直接操作成员就可以，不需要手动做位运算，代码简洁不容易错。
4. 结构体指针偏移：实现面向对象的封装
在C语言开发大型项目的时候，我们经常用struct模拟面向对象的“类”，把数据和操作数据的函数封装在一起：
struct Animal {
char name;
int age;
void (*say)(struct Animal *this); // 函数指针，相当于类的方法
};
使用的时候，我们给函数指针赋值，调用的时候把结构体自身指针传进去，就模拟了面向对象中this指针的用法，实现了简单的继承和多态。很多嵌入式的RTOS比如Linux内核里，大量用这种方式做面向对象设计，把不同类型的驱动用同一个结构体抽象，大幅提升了代码复用率。
5. 强制类型转换与结构体复用：巧解析多段数据
当我们解析协议数据的时候，经常会遇到不同格式的数据包头部相同、数据部分不同，这个时候我们可以用结构体嵌套加强制类型转换，简化解析逻辑。比如：
// 通用数据包头部
struct PacketHead {
uint16_t cmd;
uint16_t len;
};
// 命令1数据包
struct Cmd1Packet {
struct PacketHead head;
int data1;
int data2;
};
// 命令2数据包
struct Cmd2Packet {
struct PacketHead head;
char str;
};
解析的时候，我们先把收到的数据强制转换成struct PacketHead *，拿到cmd判断类型，再转换成对应命令的结构体指针，直接访问数据就可以，不需要逐个字节解析，代码非常简洁：
struct PacketHead *head = (struct PacketHead *)recv_buf;
if (head->cmd == CMD1) {
struct Cmd1Packet *cmd1 = (struct Cmd1Packet *)recv_buf;
// 直接访问cmd1->data1
}
这是网络协议解析中非常常用的技巧。
三、内存优化技巧：用好对齐规则，节省空间
struct最容易被忽略的就是内存对齐规则，很多人定义结构体的时候不注意顺序，会浪费很多不必要的内存。我们先回忆一下：编译器会按照对齐规则给结构体成员分配地址，默认情况下，结构体成员的地址会按照自身类型的大小对齐，结构体整体的大小会是最大成员大小的整数倍。
举个例子，看下面两个结构体：
// 写法一：大小是16字节
struct Test1 {
char a; // 1字节，对齐到4字节，浪费3字节
int b; // 4字节
char c; // 1字节，对齐到4字节，浪费3字节
};
// 写法二：大小是12字节，省了4字节
struct Test2 {
char a;
char c;
int b;
};
两个结构体成员完全一样，只是顺序不同，结果大小差了4字节!原因就是内存对齐规则，把小类型成员放在一起，大类型放在后面，就能减少对齐产生的填充浪费，节省内存空间。
如果你的项目内存非常紧张，还可以用编译指令修改对齐方式，比如GCC的__attribute__((packed))可以让结构体不做对齐，紧贴着分配，最小化占用空间：
struct Test {
char a;
int b;
} __attribute__((packed));
这个结构体大小就是5字节，没有填充。注意：非对齐访问可能会导致某些架构(比如ARM)性能下降，甚至访问错误，所以只有在处理协议数据、需要严格和协议定义对齐的时候才用紧凑对齐，一般场景下默认对齐就好，效率更高。
四、高级技巧：那些内核和框架常用的经典用法
很多C语言写的大型框架和内核里，还有一些非常巧妙的struct用法，我们挑两个最经典的来看：
1. 链表的“容器宏”： struct里面套链表节点
Linux内核里有一个非常经典的链表设计，叫做“侵入式链表”：不是把数据放在链表节点里，而是把链表节点嵌套在数据结构体里，通过链表节点地址反向算出数据结构体的地址。核心就是用container_of宏计算偏移，实现任意结构体都可以挂载到链表上：
// 链表节点结构，嵌套在你的数据结构体里
struct list_head {
struct list_head *next;
struct list_head *prev;
};
// 你的数据结构体，把链表节点嵌进去
struct MyData {
int value;
struct list_head node; // 嵌入链表节点
};
当你拿到链表节点node的地址，用container_of就能直接算出MyData结构体的起始地址：
#define container_of(ptr, type, member) ({ \
const typeof(((type *)0)->member) *__mptr = (ptr); \
(type *)((char *)__mptr - offsetof(type, member)); \
})
// 用法：从node指针拿到MyData指针
struct MyData *data = container_of(node, struct MyData, node);
这个设计非常灵活，同一个数据结构体可以嵌入多个链表节点，同时挂在多个不同的链表上，不需要为每个数据类型重新写链表，代码复用率极高，是非常经典的设计思路。
2. 同名结构体实现多态：不同实现统一接口
我们可以定义一个通用的操作结构体，不同的硬件驱动实现不同的函数指针，上层代码只需要调用通用结构体的函数指针，不需要关心底层具体是什么硬件，这就是C语言实现多态的经典方法。比如LCD驱动：
// 通用LCD操作结构体
struct LcdOps {
int (*init)(void);
void (*draw_pixel)(int x, int y, int color);
void (*clear)(int color);
};
// 驱动只需要给struct LcdOps赋值对应自己的函数，上层直接调用
不管是SPI接口的LCD还是RGB接口的LCD，上层代码都用同一个struct LcdOps调用接口，切换硬件只需要换一下结构体的赋值，不需要改上层代码，完美符合“面向接口编程”的设计思想。
五、常见坑点提醒：避开struct开发的常见错误
最后说几个struct开发里常见的坑，大家一定要注意：
第一个坑：sizeof(struct)计算大小的时候，别忘了内存对齐的填充，不要想当然按成员加起来算，比如前面的例子，sizeof(struct Test1)不是1+4+1=6，是16，直接用加起来的大小分配内存会出问题。
第二个坑：结构体赋值的时候，直接赋值结构体变量会复制整个结构体，如果结构体很大，会占用大量栈空间，还影响性能，尽量用指针传递，不要直接传结构体变量。
第三个坑：柔性数组不要用指针代替，很多人把最后一个成员写成int *data，以为和柔性数组一样，实际上指针本身会占用结构体大小，还需要两次分配，和柔性数组完全不一样，不要搞混。
第四个坑：位域不要跨类型边界，不同编译器对于位域跨对齐单元的处理不一样，可能会导致你预期的位置不对，如果需要精准控制布局，尽量不要让一个位域成员跨int的边界。
struct看起来是非常基础的语法，但玩透之后能衍生出非常多巧妙的用法，从简单的数据封装到复杂的面向对象设计，从内存优化到底层驱动开发，到处都能看到struct的应用。很多人觉得C语言不够灵活，实际上只要用好struct这些特性，完全能写出层次清晰、可维护性高的大型项目。
下载文档
