结构体与动态数组：结构体中包含动态数组、二次指针的使用

说实话，结构体里放动态数组，这事儿我当年刚入行时踩过不少坑。你想想看，静态数组多简单——大小固定，内存连续，编译器帮你打理一切。但现实世界的数据哪有那么规整？一个学生可能选3门课，另一个可能选8门。这时候，动态数组就派上用场了。

为什么要在结构体里放动态数组？

我做过一个项目，要管理一个实验室的设备信息。每台设备的传感器数量不一样，有的只有温度传感器，有的同时有温度、湿度、气压、振动……十几个传感器。如果用静态数组，你得按最大数量来定义，浪费内存不说，还显得很蠢。

动态数组的好处很明显：

• 节省内存——用多少，申请多少
• 灵活扩展——运行时可以调整大小
• 数据紧凑——没有浪费的空白空间

基础实现：结构体中的动态数组

我们先看一个最简单的例子。假设我们要管理一个班级的学生信息，每个学生有不定数量的成绩。

typedef struct {
    int id;
    char name[32];
    int *scores;      // 动态数组，指向成绩列表
    int score_count;  // 成绩数量
} Student;

这里的关键点：scores 是一个指针，它不存储数据本身，而是指向堆上的一块内存。初始化时，我们需要手动分配内存：

Student *create_student(int id, const char *name, int *scores, int count) {
    Student *s = (Student *)malloc(sizeof(Student));
    if (!s) return NULL;
    
    s->id = id;
    strncpy(s->name, name, sizeof(s->name) - 1);
    s->name[sizeof(s->name) - 1] = '\0';
    
    s->score_count = count;
    s->scores = (int *)malloc(count * sizeof(int));
    if (!s->scores) {
        free(s);
        return NULL;
    }
    memcpy(s->scores, scores, count * sizeof(int));
    
    return s;
}

二次指针：管理动态数组的数组

好，现在问题升级了。如果我们要管理一个班级，班级里有多个学生，每个学生又有动态的成绩数组。这就需要用二次指针了。

说白了，二次指针就是「指向指针的指针」。在结构体里，它通常用来表示一个动态数组，而这个数组的每个元素又是一个动态数组。

typedef struct {
    Student **students;  // 二次指针，指向学生指针数组
    int student_count;
} Class;

这个结构体里，students 是一个 Student **。它指向一个数组，数组的每个元素是 Student *，也就是指向学生结构体的指针。每个学生结构体内部又有自己的动态数组。

我画了一张图，帮你理清这个关系：

二次指针的初始化与释放

初始化一个班级，其实就是先分配学生指针数组，再逐个创建学生：

Class *create_class(int student_count) {
    Class *c = (Class *)malloc(sizeof(Class));
    if (!c) return NULL;
    
    c->student_count = student_count;
    c->students = (Student **)malloc(student_count * sizeof(Student *));
    if (!c->students) {
        free(c);
        return NULL;
    }
    
    // 注意：这里只是分配了指针数组，每个指针还是 NULL
    for (int i = 0; i < student_count; i++) {
        c->students[i] = NULL;
    }
    
    return c;
}

释放的时候，要一层一层来。我习惯从最内层开始释放：

void destroy_class(Class *c) {
    if (!c) return;
    
    for (int i = 0; i < c->student_count; i++) {
        if (c->students[i]) {
            // 先释放学生内部的成绩数组
            if (c->students[i]->scores) {
                free(c->students[i]->scores);
                c->students[i]->scores = NULL;
            }
            // 再释放学生结构体本身
            free(c->students[i]);
            c->students[i] = NULL;
        }
    }
    // 释放指针数组
    free(c->students);
    // 最后释放班级结构体
    free(c);
}

动态扩容：让数组能长大

实际项目中，数据量往往是未知的。我做过一个数据采集系统，传感器数量在运行过程中会动态增加。这时候就需要扩容。

扩容的核心思路：

1. 分配一块更大的新内存
2. 把旧数据拷贝过去
3. 释放旧内存
4. 更新指针和大小

int add_student_to_class(Class *c, Student *s) {
    if (!c || !s) return -1;
    
    int new_count = c->student_count + 1;
    Student **new_students = (Student **)realloc(c->students, 
                                                  new_count * sizeof(Student *));
    if (!new_students) return -1;
    
    c->students = new_students;
    c->students[c->student_count] = s;
    c->student_count = new_count;
    
    return 0;
}

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

我曾经在一个嵌入式项目中，用结构体管理传感器数据。每个传感器有不定数量的采样点。我犯了一个低级错误——在释放结构体时，忘了释放内部的动态数组。结果系统跑了三天后，内存耗尽，直接死机。

从那以后，我总结了几条铁律：

• 谁分配，谁释放——分配内存的函数也要负责释放
• 释放顺序不能乱——先内后外，先子后父
• 释放后置 NULL——防止野指针
• realloc 用临时变量——防止内存泄漏

还有一个坑：结构体赋值是浅拷贝。如果你写 Student s2 = s1;，那么 s2 和 s1 的 scores 指针指向同一块内存。修改 s2 的成绩会影响 s1。要深拷贝，得自己写函数：

Student *clone_student(const Student *src) {
    if (!src) return NULL;
    return create_student(src->id, src->name, src->scores, src->score_count);
}

实际应用场景

这种结构体套动态数组、二次指针的模式，在哪些地方最常见？

场景	说明
设备管理	每台设备有不定数量的传感器、参数
网络包解析	每个包有不定数量的TLV（类型-长度-值）字段
日志系统	每条日志有不定数量的标签、附加数据
图形界面	每个窗口有不定数量的子控件

说白了，只要数据是「一对多」且「多」的数量不确定，这种结构就非常合适。

嗯，关于结构体与动态数组、二次指针的内容，今天就聊到这里。记住一点：指针本身不占多少内存，但它指向的数据要小心管理。用好动态数组，你的程序会更灵活、更高效。

---

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