C语言笔记归纳19：动态内存管理

在 C 语言学习中，动态内存管理是绕不开的核心知识点，也是面试高频考点。普通数组、局部变量的内存大小固定，无法灵活调整，而动态内存让我们能 “按需申请、按需释放” 内存，完美解决这一痛点。本文将从基础函数用法、内存区域划分、常见错误避坑、笔试真题解析到柔性数组实战，用通俗语言 + 详细代码，帮你彻底吃透动态内存管理！

1. 🌟 为什么需要动态内存管理？（普通内存的痛点）

普通内存申请（如数组、局部变量）有三个致命缺陷：

❌ 大小固定：声明数组时必须指定长度，比如int arr[20]，用不完浪费，不够用也无法扩展；
❌ 栈区限制：局部变量、数组存放在栈区，栈区空间较小（通常几 MB），无法存储大量数据；
❌ 生命周期固定：局部变量随函数调用创建，调用结束销毁，无法长期保存数据。

动态内存管理的核心优势：

✅ 按需申请：需要多少内存就申请多少，不浪费空间；
✅ 灵活调整：内存不够时可通过realloc扩容，够用时可缩容；
✅ 自主控制：内存的申请和释放由程序员手动控制，生命周期灵活；
✅ 空间充足：堆区空间远大于栈区，可存储大量数据（如大数据、链表节点）。

// 普通内存申请的痛点示例
int main() {
    int arr[20]; // 固定80字节，用不完浪费，不够用无法扩
    int n = 100000;
    // int arr2[n]; // 栈区空间不足，会栈溢出崩溃
    return 0;
}

// 动态内存解决示例
int main() {
    int* p = (int*)malloc(100000 * sizeof(int)); // 按需申请400000字节（堆区）
    if (p != NULL) {
        // 正常使用
        free(p); // 用完释放
        p = NULL;
    }
    return 0;
}

2. 📌 程序内存区域划分（栈 / 堆 / 静态区 / 代码段）

要理解动态内存，先搞懂程序运行时的内存布局 —— 不同区域的内存有不同的生命周期和管理规则，动态内存核心在堆区：

内存区域	存储内容	生命周期	管理方式	形象比喻
栈区	局部变量、函数形参、临时数据	函数调用时创建，调用结束自动销毁	编译器自动管理（无需手动）	酒店房间：住完自动退房
堆区	动态内存（malloc/calloc/realloc）	手动申请，手动释放（或程序结束系统回收）	程序员手动管理（核心！）	自助储物柜：自己存自己取
静态区	全局变量、static 修饰的变量	程序运行期间一直存在，结束后系统回收	系统自动管理	长期租屋：租期到才退房
代码段	函数二进制代码、只读常量（如字符串常量）	程序运行期间一直存在	系统只读保护	图书馆：只能查阅不能修改

💡 关键结论：

动态内存全部存放在堆区，必须用free手动释放，否则会导致内存泄漏；
栈区空间小（几 MB），堆区空间大（几十 GB，取决于物理内存）；
全局变量、static 变量存放在静态区，生命周期长，无需手动管理。

3. 🛠️ 四大核心函数详解（malloc/calloc/realloc/free）

动态内存管理的核心是四个函数，都声明在<stdlib.h>头文件中，每个函数都有明确的用法和坑点，逐一拆解：

3.1 malloc：基础内存申请（裸空间）

函数原型：void* malloc(size_t size);

功能：向堆区申请一块连续的、大小为size字节的内存空间，返回指向该空间的指针。

核心要点：

返回值：
- 申请成功：返回指向堆区内存的void*指针（需强制转换为对应类型）；
- 申请失败：返回NULL指针（必须判断，否则会崩溃）；
参数size：申请的内存字节数（如申请 5 个 int，需5*sizeof(int)）；
内存内容：申请的内存是 “裸空间”，存储的是随机垃圾值（未初始化）；
特殊情况：若size=0，行为未定义（取决于编译器，可能返回 NULL 或无效指针）。

正确使用示例：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

int main() {
    // 需求：申请5个int的内存（20字节）
    int* p = (int*)malloc(5 * sizeof(int)); 
    
    // 关键：判断是否申请成功（避免NULL指针解引用）
    if (p == NULL) {
        perror("malloc failed"); // 打印错误信息（如：malloc failed: Not enough space）
        return 1; // 申请失败，退出程序
    }
    
    // 方法2：用assert断言（调试阶段生效，release模式失效）
    // assert(p != NULL);
    
    // 使用内存：给5个int赋值1~5
    int i = 0;
    for (i = 0; i < 5; i++) {
        *(p + i) = i + 1; // p[i] = i+1;
    }
    
    // 打印验证
    for (i = 0; i < 5; i++) {
        printf("%d ", p[i]); // 输出：1 2 3 4 5
    }
    
    // 关键：释放内存（还给操作系统）
    free(p); 
    p = NULL; // 必须置空！避免p成为野指针（指向已释放的内存）
    
    return 0;
}

易错点标注：

// ❌ 错误1：未判断NULL指针
int* p = (int*)malloc(5 * sizeof(int));
*p = 10; // 若p为NULL，会崩溃

// ❌ 错误2：free后未置空
free(p);
*p = 20; // p是野指针，非法访问内存

3.2 free：动态内存释放（必学！）

函数原型：void free(void* ptr);

功能：将ptr指向的堆区内存归还给操作系统，释放后该内存不可再访问。

核心要点：

参数ptr：
- 必须是动态内存的起始地址（malloc/calloc/realloc的返回值）；
- 若ptr=NULL，函数什么都不做（安全）；
释放后注意：
- free仅释放内存，不会改变指针ptr的值（ptr仍指向原地址）；
- 必须手动将ptr置为NULL，避免成为野指针。

错误使用示例：

// ❌ 错误1：释放非动态内存（栈区变量）
int main() {
    int a = 10;
    int* p = &a;
    free(p); // 编译可能通过，但运行崩溃（释放栈区内存，编译器不允许）
    return 0;
}

// ❌ 错误2：释放后未置空（野指针）
int main() {
    int* p = (int*)malloc(20);
    free(p);
    // p = NULL; // 忘记置空
    *p = 20; // 非法访问已释放的内存，行为未定义
    return 0;
}

3.3 calloc：带初始化的内存申请

函数原型：void* calloc(size_t num, size_t size);

功能：向堆区申请num个大小为size字节的连续内存，并将每个字节初始化为 0，返回指向该空间的指针。

与`malloc`的区别：

函数	相同点	不同点	适用场景
malloc	申请堆区内存，返回`void*`	内存未初始化（随机垃圾值）	不需要初始化的场景（省时间）
calloc	申请堆区内存，返回`void*`	内存初始化为 0（每个字节都是 0）	需要初始化为 0 的场景（如数组）

使用示例：

int main() {
    // 需求：申请5个int的内存（20字节），并初始化为0
    int* p = (int*)calloc(5, sizeof(int)); 
    
    if (p == NULL) {
        perror("calloc failed");
        return 1;
    }
    
    // 打印验证：所有元素都是0
    int i = 0;
    for (i = 0; i < 5; i++) {
        printf("%d ", p[i]); // 输出：0 0 0 0 0
    }
    
    free(p);
    p = NULL;
    return 0;
}

等价转换：

calloc(num, size) 等价于 malloc(num*size) + 手动初始化 0：

// 等价于 calloc(5, sizeof(int))
int* p = (int*)malloc(5 * sizeof(int));
memset(p, 0, 5 * sizeof(int)); // 手动初始化0（需包含<string.h>）

3.4 realloc：灵活调整内存大小（扩容 / 缩容）

函数原型：void* realloc(void* ptr, size_t size);

功能：调整ptr指向的动态内存大小为size字节，返回调整后内存的起始地址。

核心要点：

参数说明：
- ptr：动态内存的起始地址（malloc/calloc/realloc的返回值）；
- size：调整后的内存总字节数（不是增加的字节数）；
调整逻辑（三种情况）：
- 情况 1：原内存后面有足够空间 → 直接在原地址后扩容，返回原地址；
- 情况 2：原内存后面空间不足 → 在堆区找新空间，拷贝原数据→释放原空间→返回新地址；
- 情况 3：调整失败 → 返回NULL（原内存不会被释放，避免数据丢失）；
使用技巧：
- 不要用原指针接收返回值（若调整失败，原指针会被覆盖为NULL，数据丢失）；
- 先用临时指针接收，判断成功后再赋值给原指针。

正确使用示例（扩容）：

int main() {
    // 1. 先申请5个int的内存（20字节）
    int* p = (int*)malloc(5 * sizeof(int));
    if (p == NULL) {
        perror("malloc failed");
        return 1;
    }
    
    // 给初始内存赋值1~5
    int i = 0;
    for (i = 0; i < 5; i++) {
        p[i] = i + 1;
    }
    
    // 2. 需求：扩容到10个int（40字节）
    int* temp = (int*)realloc(p, 10 * sizeof(int)); // 临时指针接收
    if (temp != NULL) { // 调整成功
        p = temp; // 原指针指向新地址
        temp = NULL; // 临时指针置空
    } else { // 调整失败
        perror("realloc failed");
        free(p); // 释放原内存，避免泄漏
        p = NULL;
        return 1;
    }
    
    // 3. 给扩容后的内存赋值6~10
    for (i = 5; i < 10; i++) {
        p[i] = i + 1;
    }
    
    // 打印验证：1 2 3 4 5 6 7 8 9 10
    for (i = 0; i < 10; i++) {
        printf("%d ", p[i]);
    }
    
    free(p);
    p = NULL;
    return 0;
}

特殊用法：

realloc(NULL, size) 等价于 malloc(size)（直接申请新内存）：

int* p = (int*)realloc(NULL, 20); // 等价于 malloc(20)

易错点标注：

// ❌ 错误：用原指针接收realloc返回值
p = (int*)realloc(p, 40); 
// 若调整失败，p会被赋值为NULL，原内存地址丢失，导致内存泄漏

4. ⚠️ 六大常见动态内存错误（避坑指南）

动态内存是 C 语言 bug 的重灾区，以下 6 个错误一定要避开，每个错误都附 “错误代码 + 原因分析 + 正确写法”：

4.1 对 NULL 指针解引用

错误代码：

int main() {
    int* p = (int*)malloc(INT_MAX); // 申请超大内存，大概率失败（返回NULL）
    *p = 20; // 对NULL指针解引用，程序崩溃
    return 0;
}

原因：malloc申请失败返回NULL，直接解引用会触发内存访问错误。

正确写法：

int main() {
    int* p = (int*)malloc(INT_MAX);
    if (p == NULL) { // 必须判断
        perror("malloc failed");
        return 1;
    }
    *p = 20;
    
    free(p);
    p = NULL;
    return 0;
}

4.2 动态内存越界访问

错误代码：

void test() {
    int* p = (int*)malloc(10 * sizeof(int)); // 40字节，索引0~9
    if (p == NULL) return;
    
    for (i = 0; i <= 10; i++) { // i=10时越界（索引最大9）
        p[i] = i; 
    }
    
    free(p);
    p = NULL;
}

原因：访问了超出申请范围的内存，行为未定义（可能崩溃，也可能 “正常” 运行但埋下隐患）。正确写法：

for (i = 0; i < 10; i++) { // 严格控制索引范围（0~9）
    p[i] = i;
}

4.3 释放非动态开辟的内存

错误代码：

int main() {
    int a = 10;
    int* p = &a; // p指向栈区变量
    free(p); // 释放栈区内存，运行崩溃
    p = NULL;
    return 0;
}

原因：free仅用于释放堆区动态内存，栈区内存由编译器自动管理，不能手动释放。

正确写法：

// 仅释放动态内存
int* p = (int*)malloc(4);
free(p);
p = NULL;

4.4 释放动态内存的一部分

错误代码：

int main() {
    int* p = (int*)malloc(100);
    if (p == NULL) return;
    
    int i = 0;
    for (i = 0; i < 5; i++) {
        *p = i + 1;
        p++; // 指针后移，不再指向内存起始地址
    }
    
    free(p); // 错误：释放的是内存中间地址，不是起始地址
    p = NULL;
    return 0;
}

原因：free要求必须传入动态内存的起始地址，传入中间地址会导致释放失败（崩溃或内存泄漏）。

正确写法：

int main() {
    int* p = (int*)malloc(100);
    if (p == NULL) return;
    
    int* q = p; // 保存起始地址
    int i = 0;
    for (i = 0; i < 5; i++) {
        *q = i + 1;
        q++; // 用临时指针移动
    }
    
    free(p); // 释放起始地址
    p = NULL;
    return 0;
}

4.5 重复释放同一块内存

错误代码：

void test() {
    int* p = (int*)malloc(100);
    free(p); // 第一次释放
    // p = NULL; // 忘记置空
    free(p); // 第二次释放，运行崩溃
}

原因：同一块内存被释放两次，会破坏堆区内存管理结构，导致程序崩溃。正确写法：

void test() {
    int* p = (int*)malloc(100);
    free(p);
    p = NULL; // 释放后置空
    free(p); // 安全：NULL指针释放无效果
}

4.6 内存泄漏（最易忽略！）

错误代码：

void test() {
    int* p = (int*)malloc(100);
    if (p != NULL) {
        *p = 20;
    }
    // 忘记free，函数结束后p销毁，内存地址丢失
}

int main() {
    test();
    while (1); // 程序不结束，内存一直泄漏
    return 0;
}

原因：动态内存使用后未释放，且指向该内存的指针被销毁，导致内存地址永久丢失，系统无法回收（直到程序结束）。

危害：长期运行的程序（如服务器）会因内存泄漏耗尽内存，导致程序崩溃。

正确写法：

void test() {
    int* p = (int*)malloc(100);
    if (p != NULL) {
        *p = 20;
    }
    
    free(p); // 手动释放
    p = NULL;
}

5. 📝 4 道经典笔试错题解析（高频考点）

动态内存是笔试 / 面试的高频考点，以下 4 道题是历年真题，逐一拆解错误原因和修改方案：

例题 1：NULL 指针解引用 + 内存泄漏

#include <string.h>
void GetMemory(char* p) {
    p = (char*)malloc(100); // 形参p是局部变量，修改不影响实参str
}

void Test(void) {
    char* str = NULL;
    GetMemory(str); // 实参str仍为NULL
    strcpy(str, "hello world"); // 对NULL解引用，崩溃
    printf(str);
}

int main() {
    Test();
    return 0;
}

错误分析：

函数参数传递：GetMemory的形参p是实参str的拷贝，p指向 malloc 的内存，但str仍为 NULL；
内存泄漏：malloc申请的 100 字节地址丢失，无法释放；
NULL 解引用：strcpy(str, ...)对 NULL 指针操作，崩溃。

修改方案 1：传二级指针（推荐）

void GetMemory(char** p) {
    *p = (char*)malloc(100); // 直接修改实参str的地址
}

void Test(void) {
    char* str = NULL;
    GetMemory(&str); // 传str的地址（二级指针）
    if (str != NULL) { // 判断非NULL
        strcpy(str, "hello world");
        printf(str);
        free(str); // 释放内存
        str = NULL;
    }
}

修改方案 2：返回指针

char* GetMemory() {
    char* p = (char*)malloc(100);
    return p; // 返回malloc的地址
}

void Test(void) {
    char* str = NULL;
    str = GetMemory();
    if (str != NULL) {
        strcpy(str, "hello world");
        printf(str);
        free(str);
        str = NULL;
    }
}

例题 2：返回栈区地址（野指针）

char* GetMemory(void) {
    char p[] = "hello world"; // p是栈区局部数组
    return p; // 返回栈区地址，函数结束后p销毁
}

void Test(void) {
    char* str = NULL;
    str = GetMemory(); // str指向已销毁的栈区内存（野指针）
    printf(str); // 非法访问，行为未定义
}

错误分析：栈区变量p随函数GetMemory结束而销毁，返回的地址变为无效地址，str成为野指针。

修改方案：返回动态内存（堆区）或静态变量（静态区）：

// 方案1：返回动态内存（推荐）
char* GetMemory(void) {
    char* p = (char*)malloc(12);
    strcpy(p, "hello world");
    return p;
}

void Test(void) {
    char* str = NULL;
    str = GetMemory();
    if (str != NULL) {
        printf(str);
        free(str);
        str = NULL;
    }
}

// 方案2：返回静态变量（静态区，生命周期长）
char* GetMemory(void) {
    static char p[] = "hello world"; // 静态区数组
    return p;
}

例题 3：内存泄漏

void GetMemory(char** p, int num) {
    *p = (char*)malloc(num);
}

void Test(void) {
    char* str = NULL;
    GetMemory(&str, 100);
    strcpy(str, "hello");
    printf(str);
    // 忘记free，内存泄漏
}

错误分析：malloc申请的 100 字节未释放，导致内存泄漏。

修改方案：使用后释放内存：

void Test(void) {
    char* str = NULL;
    GetMemory(&str, 100);
    if (str != NULL) {
        strcpy(str, "hello");
        printf(str);
        free(str); // 释放
        str = NULL;
    }
}

例题 4：释放后未置空（野指针）

void Test(void) {
    char* str = (char*)malloc(100);
    strcpy(str, "hello");
    free(str); // 释放内存，但str未置空
    if (str != NULL) { // 条件为真（str仍指向原地址）
        strcpy(str, "world"); // 非法访问已释放内存
        printf(str);
    }
}

错误分析：free后str未置空，仍指向已释放的内存（野指针），if (str != NULL)判断为真，导致非法访问。

修改方案：free后立即置空：

void Test(void) {
    char* str = (char*)malloc(100);
    if (str != NULL) {
        strcpy(str, "hello");
        free(str);
        str = NULL; // 置空
    }
    if (str != NULL) { // 条件为假，不执行
        strcpy(str, "world");
        printf(str);
    }
}

6. 🚀 柔性数组（C 语言的 “动态数组”）

C 语言中没有真正的动态数组，但可以通过 “柔性数组” 实现类似功能 —— 结构体的最后一个成员是未指定大小的数组，该数组的大小可动态调整。

6.1 柔性数组的定义与核心特点

定义规则：

柔性数组必须是结构体的最后一个成员；
柔性数组前面必须至少有一个其他成员；
柔性数组的大小不计算在结构体的sizeof结果中。

// 正确定义（两种写法，等价）
struct S {
    int n; // 前面必须有其他成员
    int arr[]; // 柔性数组（写法1）
};

struct S {
    int n;
    int arr[0]; // 柔性数组（写法2，C99支持）
};

核心特点：

sizeof(struct S) = 4（仅包含int n的大小，不包含arr）；
柔性数组的内存需通过动态内存申请（malloc），大小由程序员指定；
柔性数组的内存与结构体其他成员连续，访问效率高。

6.2 柔性数组的两种使用方案（对比优化）

方案 1：柔性数组（推荐）

int main() {
    // 1. 申请内存：结构体大小 + 柔性数组大小（5个int）
    struct S* ps = (struct S*)malloc(sizeof(struct S) + 5 * sizeof(int));
    if (ps == NULL) {
        perror("malloc failed");
        return 1;
    }
    
    // 2. 初始化和使用
    ps->n = 5; // 柔性数组元素个数
    int i = 0;
    for (i = 0; i < ps->n; i++) {
        ps->arr[i] = i + 1; // 直接访问柔性数组
    }
    
    // 3. 扩容：调整为10个int
    struct S* temp = (struct S*)realloc(ps, sizeof(struct S) + 10 * sizeof(int));
    if (temp != NULL) {
        ps = temp;
        ps->n = 10;
        // 给新增元素赋值
        for (i = 5; i < 10; i++) {
            ps->arr[i] = i + 1;
        }
    }
    
    // 4. 打印验证
    for (i = 0; i < ps->n; i++) {
        printf("%d ", ps->arr[i]); // 输出：1 2 3 4 5 6 7 8 9 10
    }
    
    // 5. 释放内存（一次释放即可）
    free(ps);
    ps = NULL;
    return 0;
}

方案 2：指针模拟（传统方案）

struct S {
    int n;
    int* arr; // 用指针指向动态内存
};

int main() {
    // 1. 申请结构体内存
    struct S* ps = (struct S*)malloc(sizeof(struct S));
    if (ps == NULL) return 1;
    
    // 2. 申请指针指向的内存
    ps->arr = (int*)malloc(5 * sizeof(int));
    if (ps->arr == NULL) {
        free(ps); // 避免内存泄漏
        ps = NULL;
        return 1;
    }
    
    // 3. 使用
    ps->n = 5;
    int i = 0;
    for (i = 0; i < 5; i++) {
        ps->arr[i] = i + 1;
    }
    
    // 4. 扩容
    int* temp = (int*)realloc(ps->arr, 10 * sizeof(int));
    if (temp != NULL) {
        ps->arr = temp;
        ps->n = 10;
        for (i = 5; i < 10; i++) {
            ps->arr[i] = i + 1;
        }
    }
    
    // 5. 释放内存（需释放两次，顺序不能乱）
    free(ps->arr); // 先释放指针指向的内存
    ps->arr = NULL;
    free(ps); // 再释放结构体内存
    ps = NULL;
    return 0;
}

方案对比（柔性数组优势）

对比维度	柔性数组方案	指针模拟方案
内存连续性	结构体 + 柔性数组内存连续	结构体和指针指向的内存不连续
申请 / 释放次数	一次申请，一次释放（简单）	两次申请，两次释放（易出错）
访问效率	连续内存，访问更快	不连续，需两次指针解引用
内存碎片	少（一次申请）	多（两次申请）