C 语言 realloc() 完全指南：语法、最佳实践与实战案例

什么是 realloc()？

realloc()（re-allocation）用于调整已分配内存块的大小——既可扩大也可缩小——并在可能的情况下保留原有数据。它是实现动态数组、字符串缓冲区自动增长的核心工具，声明于 <stdlib.h>。

函数原型

void *realloc(void *ptr, size_t new_size);

• ptr：指向已由 malloc/calloc/realloc 分配的内存块指针（可为 NULL，等价于 malloc）
• new_size：新块大小（字节），为 0 时行为等同 free(ptr)（实现定义）
• 返回值：成功返回新块首地址（可能与原地址相同，也可能不同）；失败返回 NULL，原块保持不变

核心行为与关键点

1. 地址可能改变：扩容时若原址后空间不足，realloc 会分配新块、拷贝数据、释放旧块，返回新地址。必须用临时变量接收返回值，防止失败时丢失原指针导致内存泄漏。
2. 数据保留范围：保留 min(old_size, new_size) 字节的内容。缩小时尾部数据丢失；扩容时新增区域内容不确定（非零初始化）。
3. 失败安全：失败返回 NULL 且不释放原块，原指针仍有效，必须继续持有以便后续释放或重试。
4. ptr 为 NULL 时等价 malloc(new_size)；new_size 为 0 时等价 free(ptr)（C 标准允许返回 NULL 或唯一指针，不可解引用）。

实战案例 1：字符串缓冲区动态扩容

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(void) {
    char *buf = malloc(10);
    if (!buf) { perror("malloc"); return EXIT_FAILURE; }

    strcpy(buf, "Programming");
    printf("%s\n", buf);                 // Programming

    char *tmp = realloc(buf, 20);        // 扩容至 20 字节
    if (!tmp) {
        free(buf);                       // 失败时原块仍有效，需释放
        perror("realloc");
        return EXIT_FAILURE;
    }
    buf = tmp;                           // 更新指针
    strcat(buf, " in C");
    printf("%s\n", buf);                 // Programming in C

    free(buf);
    return EXIT_SUCCESS;
}

实战案例 2：整型动态数组扩容

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    int *arr = malloc(10 * sizeof(int));
    if (!arr) { perror("malloc"); return EXIT_FAILURE; }

    // 使用数组...
    for (int i = 0; i < 10; ++i) arr[i] = i * i;

    int *tmp = realloc(arr, 50 * sizeof(int));   // 扩容至 50 个 int
    if (!tmp) {
        free(arr);
        perror("realloc");
        return EXIT_FAILURE;
    }
    arr = tmp;
    printf("Array resized successfully\n");

    // 新增元素初始化
    for (int i = 10; i < 50; ++i) arr[i] = -1;

    free(arr);
    return EXIT_SUCCESS;
}

实战案例 3：实现动态数组（Vector）核心逻辑

typedef struct {
    int *data;
    size_t size;      // 当前元素数
    size_t capacity;  // 当前分配容量
} IntVec;

void vec_push(IntVec *v, int val) {
    if (v->size == v->capacity) {
        size_t new_cap = v->capacity ? v->capacity * 2 : 4;  // 倍增策略
        int *tmp = realloc(v->data, new_cap * sizeof(int));
        if (!tmp) { /* 处理 OOM */ return; }
        v->data = tmp;
        v->capacity = new_cap;
    }
    v->data[v->size++] = val;
}

关键设计：倍增策略（×2 或 ×1.5）使摊还时间复杂度为 O(1)；realloc 失败时不修改原结构体，保持强异常安全。

实战案例 4：缩容与释放

// 缩容至实际大小（去除多余容量）
int *tmp = realloc(arr, v->size * sizeof(int));
if (tmp) arr = tmp;   // 缩容失败不影响正确性，仅保留多余容量

实用技巧与最佳实践

• 永远用临时变量：tmp = realloc(ptr, sz); if (tmp) ptr = tmp; else handle_error();
• 优先用 size_t：避免有符号整数溢出、隐式转换 Bug。
• 缩容谨慎：频繁缩容/扩容导致碎片化，通常仅在明确不再增长时缩容（shrink_to_fit 模式）。
• 扩容后新增区域未初始化：如需清零，显式 memset(ptr + old_len, 0, added_bytes)。
• 对齐感知：realloc 保持对齐，可安全转型为任何类型指针。
• 避免 realloc(ptr, 0)：行为实现定义，显式 free(ptr); ptr=NULL; 更清晰。

常见错误对照

调试与分析工具

• valgrind --leak-check=full --track-origins=yes 检测泄漏、越界、双重释放
• gcc -fsanitize=address -fno-omit-frame-pointer -g 地址消毒器实时捕获
• 自定义分配器记录每次 realloc 的旧/新地址、大小、调用栈，分析碎片化

总结

realloc() 是 C 语言构建可变长数据结构的利器。核心铁律：用临时变量接收返回值、检查 NULL、理解地址可能变、新增区域不清零、缩容丢尾部数据。掌握这些，即可安全高效地实现动态数组、字符串构建器、缓冲区管理等核心组件。