动态内存分配函数详解[3]：realloc()

byte轻骑兵

发布于 2026-01-20 16:50:48

1250

在 C 语言动态内存管理的三大利器中，malloc()负责分配、calloc()专注初始化，而realloc()则扮演着 “弹性调节器” 的角色 —— 它能动态调整已分配内存的大小，让程序在运行时根据实际需求灵活管理内存资源。这种动态伸缩能力使其在处理未知大小数据（如用户输入、文件内容）时不可或缺。

一、函数简介

realloc()（全称 “reallocate”）的核心功能是调整已分配内存块的大小，它填补了malloc()和calloc()在内存动态管理上的空白。在实际开发中，很多数据的大小在编译期无法确定（如用户输入的字符串长度、从文件读取的记录条数），此时realloc()就成为了连接 “静态声明” 与 “动态需求” 的桥梁。

1.1 为什么需要 realloc ()？

想象一个场景：你需要编写一个程序读取用户输入的一行文本，但无法预知用户会输入多少个字符。如果用固定大小的数组（如char buf[100]），可能面临两种尴尬：

数组太小，用户输入超长导致缓冲区溢出；
数组太大，浪费宝贵的内存资源。

realloc()通过 “按需调整” 完美解决了这个问题：先分配一个初始大小的内存块，随着数据量增加逐步扩展，既避免溢出风险，又减少内存浪费。这种 “弹性” 在以下场景中尤为重要：

动态数组（如链表之外的可变长序列）；
缓冲区管理（如网络数据接收、文件内容缓存）；
内存优化（释放不再需要的多余空间）。

1.2 与其他分配函数的本质区别

函数	核心功能	关键特性	典型场景
malloc(size)	分配指定字节的内存	不初始化，返回未清零内存	已知大小且无需初始化的内存
calloc(num, size)	分配num*size字节并清零	自动初始化，适合数组	需要初始化为零的结构 / 数组
realloc(ptr, size)	调整已有内存块的大小	可能保留原有数据，返回新指针	动态扩展 / 收缩内存块

realloc()的独特之处在于它与已分配的内存块存在 “关联”—— 它不是凭空分配新内存，而是基于已有的ptr指针（必须是malloc()/calloc()/realloc()返回的指针）进行调整，这使得它能够在调整大小时尽可能保留原有数据。

二、函数原型

realloc()的原型看似简单，却蕴含着复杂的行为规则，理解这些规则是正确使用的前提：

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

2.1 参数解析：两个参数的深层含义

1. void *ptr：指向已分配内存块的指针，有三种特殊情况：

ptr == NULL：realloc()的行为等价于malloc(size)，即分配size字节的新内存；
ptr是未通过malloc()/calloc()/realloc()分配的指针（如栈上变量的地址）：行为未定义，可能导致程序崩溃或内存损坏；
ptr已被free()释放：属于 “野指针” 误用，行为未定义，是常见的内存错误源。

2. size_t size：新内存块的大小（字节数），有两种边界情况：

size == 0：realloc()的行为等价于free(ptr)，返回NULL（部分实现），但标准未严格规定，需谨慎使用；
size大于原有内存块大小：需要扩展内存，可能需要搬迁数据；
size小于原有内存块大小：可能收缩内存，截断超出部分的数据。

2.2 返回值：新指针的多重含义

realloc()的返回值是调整大小后的内存块指针，需要重点理解：

成功调整：返回指向新内存块的指针（可能与原ptr相同，也可能不同）；
分配失败：返回NULL，此时原内存块ptr仍然有效（这是关键！避免内存泄漏的核心）；
特殊情况：当size=0时，多数实现返回NULL，但原内存已被释放。

返回值与原指针的关系是realloc()最容易出错的地方 —— 很多开发者误以为返回的指针一定与ptr相同，或在分配失败时错误地丢弃了原指针。

三、函数实现（伪代码）

realloc()的实现逻辑远比malloc()复杂，它需要在 “保持数据” 和 “高效调整” 之间找到平衡。不同编译器的实现细节可能不同，但核心机制一致。

3.1 核心工作流程（伪代码）

void *realloc(void *ptr, size_t size) {
    // 情况1：ptr为NULL，等价于malloc(size)
    if (ptr == NULL) {
        return malloc(size);
    }

    // 情况2：size为0，等价于free(ptr)并返回NULL
    if (size == 0) {
        free(ptr);
        return NULL;
    }

    // 步骤1：获取原内存块的信息（大小、位置等）
    BlockInfo *old_block = get_block_info(ptr);  // 内部函数，获取元数据
    size_t old_size = old_block->size;

    // 步骤2：若新大小 <= 原大小，尝试原地收缩
    if (size <= old_size) {
        shrink_block(old_block, size);  // 调整元数据，可能释放多余空间
        return ptr;  // 指针不变
    }

    // 步骤3：需要扩展，检查原内存块后面是否有足够空间
    if (has_enough_space_after(old_block, size - old_size)) {
        expand_block_in_place(old_block, size);  // 原地扩展
        return ptr;  // 指针不变
    }

    // 步骤4：原地扩展失败，分配新内存块
    void *new_ptr = malloc(size);
    if (new_ptr == NULL) {
        return NULL;  // 分配失败，原内存保持不变
    }

    // 步骤5：复制原有数据到新内存（仅复制较小的大小）
    size_t copy_size = (old_size < size) ? old_size : size;
    memcpy(new_ptr, ptr, copy_size);

    // 步骤6：释放原内存块
    free(ptr);

    // 步骤7：返回新指针
    return new_ptr;
}

3.2 关键机制解析

1. 原地调整 vs 搬迁复制：

当需要收缩内存（size < 原大小）：通常可以原地完成，只需调整内存块的元数据，标记多余部分为空闲；
当需要扩展内存（size > 原大小）：取决于原内存块后面是否有连续的空闲空间（“内存碎片” 情况）：
- 有足够空间：原地扩展，指针不变；
- 空间不足：分配新内存块，复制数据，释放旧块，返回新指针。

2. 数据复制的规则：

若size > 原大小：复制全部原有数据到新块；
若size < 原大小：仅保留前size字节数据，超出部分被截断（丢失）。

3. 与内存分配器的协作：

realloc()依赖底层内存分配器（如 glibc 的 ptmalloc、Windows 的 CRT heap）的元数据管理，这些元数据通常存储在内存块的头部（ptr之前的区域），记录块大小、是否空闲等信息；
高效的内存分配器会通过 “内存合并” 减少碎片，提高realloc()原地扩展的成功率。

四、使用场景

realloc()的弹性使其在多种动态场景中不可或缺，以下是最能发挥其价值的典型场景。

1. 动态数组的扩展

动态数组是realloc()最经典的应用场景。例如，读取未知数量的整数并存储：

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

int main() {
    size_t capacity = 4;  // 初始容量
    size_t count = 0;     // 当前元素数量
    int *numbers = malloc(capacity * sizeof(int));  // 初始分配

    if (numbers == NULL) {
        perror("malloc failed");
        return 1;
    }

    int num;
    printf("输入整数（输入0结束）：\n");
    while (1) {
        scanf("%d", &num);
        if (num == 0) break;

        // 若容量不足，扩展为原来的2倍（减少realloc调用次数）
        if (count >= capacity) {
            capacity *= 2;
            int *new_numbers = realloc(numbers, capacity * sizeof(int));
            if (new_numbers == NULL) {
                perror("realloc failed");
                free(numbers);  // 释放原内存，避免泄漏
                return 1;
            }
            numbers = new_numbers;  // 更新指针
            printf("已扩展容量至：%zu\n", capacity);
        }

        numbers[count++] = num;
    }

    // 输出结果
    printf("你输入了%d个数字：", count);
    for (size_t i = 0; i < count; i++) {
        printf("%d ", numbers[i]);
    }

    // 释放内存
    free(numbers);
    return 0;
}

优势：通过 “按需扩展”（通常每次翻倍），既满足动态需求，又减少realloc()的调用次数（每次调用可能涉及数据复制，开销较大）。

2. 缓冲区动态调整

在处理变长输入（如用户输入的字符串）时，realloc()可以动态扩展缓冲区，避免固定大小的限制：

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

#define INITIAL_SIZE 16  // 初始缓冲区大小

char *read_dynamic_string() {
    size_t capacity = INITIAL_SIZE;
    size_t length = 0;
    char *buffer = malloc(capacity);
    if (buffer == NULL) return NULL;

    int c;
    while ((c = fgetc(stdin)) != EOF && c != '\n') {
        // 若缓冲区满，扩展为原来的1.5倍
        if (length + 1 >= capacity) {  // +1留空给终止符'\0'
            capacity = (capacity * 3) / 2;  // 1.5倍扩展策略
            char *new_buffer = realloc(buffer, capacity);
            if (new_buffer == NULL) {
                free(buffer);
                return NULL;
            }
            buffer = new_buffer;
        }
        buffer[length++] = (char)c;
    }
    buffer[length] = '\0';  // 添加字符串终止符

    // 可选：收缩缓冲区至实际需要的大小（优化内存）
    char *final_buffer = realloc(buffer, length + 1);
    return final_buffer ? final_buffer : buffer;  // 若失败，返回原缓冲区
}

int main() {
    printf("输入一行文本：");
    char *str = read_dynamic_string();
    if (str != NULL) {
        printf("你输入了：%s（长度：%zu）\n", str, strlen(str));
        free(str);
    }
    return 0;
}

扩展策略：1.5 倍扩展比 2 倍扩展更节省内存（减少内存碎片）；
最终收缩：通过realloc()将缓冲区调整为实际长度，避免内存浪费。

3. 内存使用优化（收缩多余空间）

当内存块的实际需求小于已分配大小时，realloc()可以收缩内存，释放多余空间：

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

// 从文件读取数据，初始分配较大缓冲区，最后收缩
void read_and_optimize_memory(const char *filename) {
    FILE *file = fopen(filename, "r");
    if (file == NULL) {
        perror("fopen failed");
        return;
    }

    // 初始分配1MB缓冲区
    size_t capacity = 1024 * 1024;
    char *buffer = malloc(capacity);
    if (buffer == NULL) {
        fclose(file);
        return;
    }

    // 读取文件内容（简化示例）
    size_t bytes_read = fread(buffer, 1, capacity, file);
    printf("实际读取字节数：%zu\n", bytes_read);

    // 收缩缓冲区至实际大小
    char *optimized_buffer = realloc(buffer, bytes_read);
    if (optimized_buffer != NULL) {
        buffer = optimized_buffer;
        printf("内存已优化，新大小：%zu字节\n", bytes_read);
    } else {
        printf("内存优化失败，保持原大小\n");
    }

    // 使用缓冲区...

    free(buffer);
    fclose(file);
}

int main() {
    read_and_optimize_memory("example.txt");
    return 0;
}

适用场景：临时需要大缓冲区但最终数据量较小的情况（如解析文件、处理网络数据包）。

五、使用注意事项

realloc()的灵活性伴随着高风险，使用不当可能导致内存泄漏、数据丢失甚至程序崩溃。以下是必须严格遵守的注意事项。

1. 永远不要直接覆盖原指针

这是realloc()最常见的错误！若realloc()失败返回NULL，直接赋值会导致原指针丢失，造成内存泄漏：

// 错误示例：直接覆盖原指针
int *ptr = malloc(100);
ptr = realloc(ptr, 200);  // 若失败，ptr变为NULL，原内存块无法释放

// 正确示例：先用临时指针接收返回值
int *ptr = malloc(100);
int *new_ptr = realloc(ptr, 200);
if (new_ptr != NULL) {
    ptr = new_ptr;  // 仅在成功时更新指针
} else {
    // 处理失败，ptr仍指向原内存块
    fprintf(stderr, "扩展内存失败，继续使用原内存\n");
}

2. 原指针必须是有效分配的内存

向realloc()传递无效指针（如栈指针、已释放的指针）会导致未定义行为：

// 错误1：传递栈指针
int stack_var;
int *bad_ptr = realloc(&stack_var, 100);  // 行为未定义，可能崩溃

// 错误2：传递已释放的指针
int *ptr = malloc(100);
free(ptr);
ptr = realloc(ptr, 200);  // 野指针误用，可能破坏堆结构

3. 处理 size=0 的特殊情况

size=0时realloc()的行为因实现而异，标准未强制规定，建议避免使用：

int *ptr = malloc(100);
// 不推荐：size=0的行为不确定
ptr = realloc(ptr, 0);  // 可能释放内存并返回NULL，但并非所有实现都如此

// 推荐：明确使用free()释放内存
free(ptr);
ptr = NULL;

4. 数据复制的开销不可忽视

当realloc()需要分配新内存块时，会复制原有数据，时间复杂度为 O (n)（n 为原内存大小）。频繁在大内存块上调用realloc()可能导致性能问题：

// 性能较差：频繁对大内存块调用realloc()
char *buffer = malloc(1);
for (int i = 0; i < 1000000; i++) {
    buffer = realloc(buffer, i + 2);  // 每次扩展1字节，触发大量复制
}

// 性能更好：批量扩展（如每次翻倍）
size_t capacity = 1;
char *buffer = malloc(capacity);
for (int i = 0; i < 1000000; i++) {
    if (i >= capacity) {
        capacity *= 2;  // 翻倍扩展，减少复制次数
        char *new_buf = realloc(buffer, capacity);
        if (new_buf) buffer = new_buf;
    }
}

5. 扩展后的数据初始化

realloc()仅复制原有数据，扩展的新区域不会被初始化（与malloc()一致），使用前需手动初始化：

int *ptr = calloc(4, sizeof(int));  // 初始4个int，全为0
int *new_ptr = realloc(ptr, 8 * sizeof(int));
if (new_ptr != NULL) {
    ptr = new_ptr;
    // 扩展的4个int未初始化，需手动清零
    for (int i = 4; i < 8; i++) {
        ptr[i] = 0;
    }
}

6. 与 free () 的配合使用

realloc()调整后的内存块仍需用free()释放，且只能释放一次：

int *ptr = malloc(100);
int *new_ptr = realloc(ptr, 200);
if (new_ptr != NULL) {
    ptr = new_ptr;
}
free(ptr);  // 正确：释放最终的内存块
// free(new_ptr);  // 错误：重复释放（若new_ptr非NULL）

六、示例代码：realloc () 实战进阶

以下通过三个复杂示例，展示realloc()在实际开发中的高级应用，涵盖错误处理、性能优化和边缘情况处理。

示例 1：动态二维数组的管理

动态二维数组需要先分配行指针数组，再为每行分配内存。当需要扩展行数时，realloc()可以灵活调整：

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

// 创建初始行数为rows，每行cols个整数的二维数组
int **create_2d_array(size_t rows, size_t cols) {
    // 分配行指针数组
    int **array = malloc(rows * sizeof(int *));
    if (array == NULL) return NULL;

    // 为每行分配内存
    for (size_t i = 0; i < rows; i++) {
        array[i] = calloc(cols, sizeof(int));  // 初始化为0
        if (array[i] == NULL) {
            // 分配失败，回滚已分配的内存
            for (size_t j = 0; j < i; j++) free(array[j]);
            free(array);
            return NULL;
        }
    }
    return array;
}

// 扩展二维数组的行数（新增new_rows行）
int **expand_2d_array(int **array, size_t old_rows, size_t new_rows, size_t cols) {
    // 扩展行指针数组
    int **new_array = realloc(array, new_rows * sizeof(int *));
    if (new_array == NULL) {
        return NULL;  // 失败时原数组仍有效
    }

    // 为新增的行分配内存
    for (size_t i = old_rows; i < new_rows; i++) {
        new_array[i] = calloc(cols, sizeof(int));
        if (new_array[i] == NULL) {
            // 回滚：释放新增的行和新指针数组，返回原数组
            for (size_t j = old_rows; j < i; j++) free(new_array[j]);
            free(new_array);  // 注意：原array已被realloc释放，不能再用
            return NULL;
        }
    }
    return new_array;
}

int main() {
    size_t rows = 2, cols = 3;
    int **matrix = create_2d_array(rows, cols);
    if (matrix == NULL) {
        perror("创建二维数组失败");
        return 1;
    }

    // 初始化数据
    matrix[0][0] = 1; matrix[0][1] = 2; matrix[0][2] = 3;
    matrix[1][0] = 4; matrix[1][1] = 5; matrix[1][2] = 6;

    // 扩展为4行
    size_t new_rows = 4;
    int **expanded = expand_2d_array(matrix, rows, new_rows, cols);
    if (expanded == NULL) {
        perror("扩展失败");
    } else {
        matrix = expanded;
        rows = new_rows;
        printf("扩展成功，新行数：%zu\n", rows);
        // 新增行已初始化为0，可直接使用
        matrix[2][0] = 7;  // 访问第三行
    }

    // 打印数组
    for (size_t i = 0; i < rows; i++) {
        for (size_t j = 0; j < cols; j++) {
            printf("%d ", matrix[i][j]);
        }
        printf("\n");
    }

    // 释放二维数组
    for (size_t i = 0; i < rows; i++) free(matrix[i]);
    free(matrix);
    return 0;
}

关键技巧：扩展失败时的回滚机制 —— 释放部分分配的新内存，确保不泄漏。

示例 2：实现一个安全的动态字符串库

封装realloc()实现一个支持动态拼接、插入的字符串库，展示realloc()在复杂数据结构中的应用：

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

// 动态字符串结构体
typedef struct {
    char *data;    // 存储字符串
    size_t length; // 当前长度（不含终止符）
    size_t capacity;// 容量（已分配大小）
} DynamicString;

// 初始化动态字符串
DynamicString *ds_init(size_t initial_capacity) {
    DynamicString *ds = malloc(sizeof(DynamicString));
    if (ds == NULL) return NULL;

    ds->capacity = initial_capacity > 0 ? initial_capacity : 16;  // 最小容量16
    ds->data = malloc(ds->capacity);
    if (ds->data == NULL) {
        free(ds);
        return NULL;
    }
    ds->data[0] = '\0';
    ds->length = 0;
    return ds;
}

// 拼接字符串
int ds_append(DynamicString *ds, const char *str) {
    if (ds == NULL || str == NULL) return -1;

    size_t str_len = strlen(str);
    size_t needed = ds->length + str_len + 1;  // +1 for '\0'

    // 若容量不足，扩展至至少needed大小（翻倍策略）
    if (needed > ds->capacity) {
        while (ds->capacity < needed) {
            ds->capacity *= 2;  // 翻倍直到足够
        }
        char *new_data = realloc(ds->data, ds->capacity);
        if (new_data == NULL) {
            return -1;  // 失败时原字符串保持不变
        }
        ds->data = new_data;
    }

    // 拼接字符串
    strcat(ds->data + ds->length, str);
    ds->length += str_len;
    return 0;
}

// 释放动态字符串
void ds_free(DynamicString *ds) {
    if (ds != NULL) {
        free(ds->data);
        free(ds);
    }
}

int main() {
    DynamicString *ds = ds_init(8);  // 初始容量8
    if (ds == NULL) {
        perror("初始化失败");
        return 1;
    }

    // 拼接字符串
    ds_append(ds, "Hello");
    ds_append(ds, " ");
    ds_append(ds, "World!");

    printf("结果：%s（长度：%zu，容量：%zu）\n",
           ds->data, ds->length, ds->capacity);
    // 输出：Hello World!（长度：12，容量：16）

    ds_free(ds);
    return 0;
}

封装realloc()的扩展逻辑，对外提供简单接口；
采用翻倍扩容策略，减少realloc()调用次数；
失败处理确保原数据不丢失，安全性高。

示例 3：realloc () 错误处理与内存泄漏防范

模拟realloc()失败场景，展示如何安全处理以避免内存泄漏：

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

// 安全扩展内存的函数
void *safe_realloc(void *ptr, size_t new_size, size_t *old_size) {
    void *new_ptr = realloc(ptr, new_size);
    if (new_ptr == NULL) {
        fprintf(stderr, "realloc失败：无法分配%d字节\n", new_size);
        return NULL;  // 原指针仍有效
    }
    *old_size = new_size;  // 更新记录的大小
    return new_ptr;
}

int main() {
    size_t current_size = 100;
    int *data = malloc(current_size * sizeof(int));
    if (data == NULL) {
        perror("初始分配失败");
        return 1;
    }

    // 初始化数据
    for (size_t i = 0; i < current_size; i++) {
        data[i] = i;
    }

    // 尝试扩展内存（模拟可能失败的场景）
    size_t new_size = current_size * 2;
    int *new_data = safe_realloc(data, new_size * sizeof(int), &current_size);
    if (new_data != NULL) {
        data = new_data;
        printf("内存扩展成功，新大小：%zu\n", new_size);
        // 初始化新扩展的区域
        for (size_t i = new_size / 2; i < new_size; i++) {
            data[i] = i;
        }
    } else {
        printf("使用原内存大小：%zu\n", current_size);
    }

    // 使用数据...

    free(data);  // 无论扩展是否成功，都能安全释放
    return 0;
}

用包装函数safe_realloc()统一处理错误；
通过old_size参数跟踪当前内存大小，避免信息丢失；
确保无论realloc()成功与否，都能安全释放内存。

七、realloc () 的艺术与平衡

realloc()是 C 语言动态内存管理的 “瑞士军刀”，它的弹性使其在处理未知大小数据时无可替代，但也因复杂的行为规则成为内存错误的高发区。掌握realloc()的核心在于理解以下平衡：

灵活性与安全性的平衡：realloc()的动态调整能力带来便利，但必须通过严格的指针管理（不直接覆盖原指针、检查返回值）确保安全；
性能与功能的平衡：通过合理的扩展策略（如翻倍扩容）减少realloc()的调用次数，降低数据复制的开销；
简洁性与健壮性的平衡：封装realloc()为安全接口（如示例 2 的动态字符串库），既简化使用，又保证健壮性。

在实际开发中，realloc()最常见的错误并非语法错误，而是对其行为规则的误解 —— 尤其是 “返回新指针可能与原指针不同” 和 “失败时原内存保持有效” 这两点。记住：永远用临时指针接收realloc()的返回值，永远检查返回值是否为 NULL。

随着内存安全语言（如 Rust）的兴起，手动内存管理的重要性有所下降，但realloc()所代表的动态资源调整思想 ——“按需分配，及时释放”—— 仍是程序设计的核心原则。理解realloc()的工作机制，不仅能帮助你写出更安全的 C 代码，更能深化对内存管理本质的认识。

博主简介：byte轻骑兵，现就职于国内知名科技企业，专注于嵌入式系统研发。深耕 Android、Linux、RTOS、通信协议、AIoT、物联网及 C/C++ 等领域。乐于技术分享与交流，欢迎关注互动！ CSDN主页地址：https://blog.csdn.net/weixin_37800531?type=blog 知乎主页地址：https://www.zhihu.com/people/38-72-36-20-51 微信公众号：「嵌入式硬核研究所」 联系邮箱：byteqqb@163.com（技术咨询 / 商业合作请备注需求） 声明：本文为「byte轻骑兵」原创文章，未经授权禁止任何形式转载。商业合作、内容授权请通过上述邮箱联系。

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2025-09-16，如有侵权请联系 cloudcommunity@tencent.com 删除

数据