结构体与动态内存：malloc/free 分配结构体、柔性数组成员

说实话，结构体跟动态内存搭配使用，是C语言里非常实用的一招。我早年做嵌入式通信协议栈的时候，数据包长度不确定，要是都用固定数组，要么浪费内存，要么不够用。后来用上了动态分配，才真正体会到什么叫「灵活」。今天我们就聊聊这个话题。

为什么结构体需要动态分配？

你想想看，平时我们定义结构体变量，都是在栈上分配的。栈空间有限，尤其是嵌入式环境，可能就几KB。如果你要管理一个链表、树，或者不确定数量的设备信息，栈上根本放不下。

另一个场景：你写一个函数，要返回一个结构体。如果结构体很大，按值返回会拷贝整个结构体，效率低。如果返回指针，那指针指向的内存必须是动态分配的，否则函数结束局部变量就销毁了。

说白了，动态内存让结构体的生命周期不再受限于作用域。你可以在函数里创建，在别的地方释放，非常自由。

malloc/free 分配结构体

先看一个基础例子。假设我们要管理一个学生信息：

typedef struct {
    int id;
    char name[32];
    float score;
} Student;

// 动态分配一个学生
Student *p = (Student *)malloc(sizeof(Student));
if (p == NULL) {
    // 处理分配失败
    return;
}
p->id = 1001;
strcpy(p->name, "张三");
p->score = 89.5;

// 使用完毕后释放
free(p);
p = NULL;  // 我习惯置空，防止野指针

这里有几个要点：

  • sizeof(Student) 不要写成固定数字。不同平台对齐方式不同，sizeof 最安全。
  • malloc 返回 void*，需要强制转型。C语言中可以不转，但我建议转，代码更清晰。
  • 检查 NULL。嵌入式环境下内存紧张，分配失败是常有的事。我曾经在一个项目中忘了检查，结果系统跑飞了，查了半天才发现是空指针解引用。
  • free 后置 NULL。虽然不强制，但这是好习惯。避免多次 free 导致崩溃。

动态分配结构体数组

有时候我们需要不确定数量的结构体。比如一个班级的学生人数是运行时才知道的：

int count = get_student_count();
Student *class = (Student *)malloc(count * sizeof(Student));
if (class == NULL) {
    // 错误处理
}

// 像数组一样使用
for (int i = 0; i < count; i++) {
    class[i].id = i + 1;
    sprintf(class[i].name, "学生%d", i + 1);
}

// 释放
free(class);

注意：这里 free 一次就够了，不要对每个元素单独 free。因为整个数组是一次 malloc 分配的连续内存。

⚠️ 常见错误： 有人会写 free(class[0]) 或者对每个元素 free，这是错误的。只有 malloc 返回的指针才能传给 free。

柔性数组成员（Flexible Array Member）

这个特性是 C99 引入的，我个人非常喜欢。它解决了一个经典问题：结构体末尾需要一个变长数组，但你又不想用指针再单独分配一块内存。

先看传统做法：

// 传统方式：用指针
typedef struct {
    int len;
    char *data;  // 需要额外 malloc
} Buffer1;

// 使用时需要两次分配
Buffer1 *buf = malloc(sizeof(Buffer1));
buf->data = malloc(100);

这样有两个问题：一是内存碎片，二是释放时要先释放 data，再释放 buf，容易漏掉。

柔性数组成员的做法：

typedef struct {
    int len;
    char data[];  // 柔性数组成员，不占结构体大小
} Buffer2;

// 一次分配搞定
int size = 100;
Buffer2 *buf = malloc(sizeof(Buffer2) + size);
buf->len = size;
// 直接使用 buf->data[0] 到 buf->data[size-1]

// 释放也简单
free(buf);

这里的关键点：

  • data[] 不占 sizeof(Buffer2) 的空间。sizeof(Buffer2) 只包含 len 和对齐填充。
  • 分配时：sizeof(Buffer2) + 你要的数组大小。
  • 释放时：一次 free 搞定，不会内存泄漏。
💡 我的经验： 在通信协议解析中，我经常用柔性数组来存储变长报文。比如一个数据包，前面是固定头部，后面是变长负载。用柔性数组，一次 malloc 就能拿到完整的内存块，解析起来非常顺手。

柔性数组的注意事项

  1. 柔性数组成员必须是最后一个成员。 这是语法规定。
  2. 一个结构体只能有一个柔性数组成员。
  3. 不能使用 sizeof 获取柔性数组的大小。 它不占空间，sizeof 返回的是固定部分的大小。
  4. 不能直接声明柔性数组的变量。 比如 Buffer2 b; 是不行的，因为编译器不知道数组多大。必须用指针 + malloc。
  5. 不能作为结构体数组的元素。 比如 Buffer2 arr[10]; 会编译错误。
📌 小技巧： 如果你需要多个变长字段，可以把它们打包成一个子结构体，然后用一个柔性数组指向它。或者干脆用两个指针分别分配，虽然麻烦点，但更灵活。

动态结构体的常见陷阱

我总结几个自己踩过的坑：

  • 忘记检查 malloc 返回值。 嵌入式环境尤其要小心。我曾经在内存不足时直接用了 NULL 指针，导致 hard fault。
  • 多次 free 同一块内存。 这是 double free，会导致堆损坏。我的习惯是 free 后立即置 NULL。
  • 结构体包含指针时，只 free 了结构体本身。 如果结构体里有 malloc 出来的指针，要先 free 内部指针，再 free 结构体。柔性数组可以避免这个问题。
  • sizeof 结构体时忽略了对齐。 不同编译器对齐方式不同，sizeof 结果可能比你想象的大。不要手动计算，用 sizeof 最安全。

知识体系图

下面这张图总结了结构体与动态内存的核心逻辑：

结构体与动态内存 知识体系 动态内存分配 malloc/free 分配结构体 柔性数组成员 单个结构体分配 结构体数组分配 变长数据一次分配 避免内存碎片 核心原则：谁分配，谁释放；检查 NULL；free 后置 NULL

总结

结构体与动态内存的结合，是C语言中非常强大的工具。malloc/free 让你能灵活管理结构体的生命周期，柔性数组则让变长数据的处理变得优雅高效。

我个人建议：在嵌入式系统中，尽量用柔性数组替代「结构体+内部指针」的模式，减少内存碎片和泄漏风险。当然，如果结构体里需要多个变长字段，那就只能退回到指针方案了。

嗯，最后提醒一句：动态内存虽好，但不要滥用。能静态分配的就静态分配，动态分配只在必要时使用。毕竟，malloc 和 free 是有开销的，而且容易出错。

公众号:蓝海资料掘金营，微信deep3321

← 上一章 📖 返回目录 下一章 →