C语言中reserve是什么函数？

C 语言标准库中没有名为 reserve 的函数，这个术语通常出现在 C++ 的 std::string 类中，用于预留内存空间，以避免频繁的内存分配。

在 C 语言中，我们处理字符串和动态数组时，“预留空间”这个概念的核心思想是完全一样的，它的目标就是预先分配一块足够大的内存，以应对未来可能的数据增长，从而减少或避免在程序运行时频繁调用内存分配函数（如 malloc、realloc），因为内存分配和释放是相对耗时的操作。

下面我将从几个方面来解释 C 语言中如何实现“预留空间”的思想。

为什么需要“预留空间”？（动机）

想象一下你要往一个杯子里倒水,但你不知道要倒多少水。

• 不预留（动态增长）：你用一个很小的杯子（1MB），当水满了，你就得去找一个新的大杯子（2MB），把旧杯子里的水倒进去，扔掉旧杯子，如果水又满了，再重复这个过程，这个过程非常耗时，尤其是在数据量很大时。
• 预留空间（预分配）：你一开始就准备一个足够大的杯子（10MB），这样，你可以倒很多次水，杯子都不会满，完全不需要去换杯子，虽然一开始可能浪费了一些空间，但效率大大提高了。

在 C 语言中，这个过程对应的就是：

• 动态增长：频繁调用 realloc 来扩大内存块。
• 预留空间：一次性调用 malloc 或 calloc 分配一个较大的初始容量，当容量不够时，再一次性地、成倍地扩大（容量变为原来的 2 倍）。

C 语言中实现“预留空间”的常见场景和方法

C 语言没有内置的字符串类型，我们通常用字符数组（静态或动态）来模拟，动态数组是实现“预留空间”思想最经典的地方。

动态增长的字符串（模拟 C++ 的 std::string）

这是一个非常常见的例子,比如实现一个简单的读取一行输入的函数，或者一个字符串拼接函数。

不使用预留空间（低效的方式）：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// 劣质实现：每次增长都重新分配
char* read_line_inefficient() {
    size_t capacity = 1; // 初始容量
    size_t size = 0;    // 当前长度
    char *buffer = malloc(capacity * sizeof(char));
    if (!buffer) return NULL;
    int c;
    while ((c = getchar()) != '\n' && c != EOF) {
        // 每次增加一个字符，检查是否需要扩容
        if (size + 1 >= capacity) { // +1 是为了给 '\0' 留空间
            capacity += 1; // 每次只增加1个字节，效率极低
            char *new_buffer = realloc(buffer, capacity);
            if (!new_buffer) {
                free(buffer);
                return NULL;
            }
            buffer = new_buffer;
        }
        buffer[size++] = (char)c;
    }
    buffer[size] = '\0';
    return buffer;
}

这个函数的效率非常低,因为输入每增加一个字符，都可能触发一次 realloc。

使用预留空间（高效的方式）：

这是更优的实现,我们采用“容量翻倍”的策略。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// 优质实现：使用指数增长策略预留空间
char* read_line_efficient() {
    size_t capacity = 16; // 初始容量，设为一个合理的值
    size_t size = 0;
    char *buffer = malloc(capacity * sizeof(char));
    if (!buffer) return NULL;
    int c;
    while ((c = getchar()) != '\n' && c != EOF) {
        // 检查是否需要扩容
        if (size + 1 >= capacity) { // +1 是为了给 '\0' 留空间
            // 容量翻倍，这是一个常见的策略，平衡了内存使用和效率
            capacity *= 2;
            char *new_buffer = realloc(buffer, capacity);
            if (!new_buffer) {
                free(buffer);
                return NULL;
            }
            buffer = new_buffer;
        }
        buffer[size++] = (char)c;
    }
    buffer[size] = '\0';
    return buffer;
}

分析：

• 初始容量：我们选择一个合理的初始值（如 16），避免了从 1 开始的缓慢增长。
• 增长策略：当空间不足时，将容量 capacity 乘以 2，这意味着：
  • 输入 16 个字符后，扩容到 32。
  • 输入 32 个字符后，扩容到 64。
  • 输入 64 个字符后，扩容到 128。
• 优点：realloc 的调用次数从 O(n)（n 是输入长度）降低到了 O(log n)，对于一个 1024 字符的输入，低效版本可能调用 1000+ 次 realloc，而高效版本只需调用约 10 次（16 -> 32 -> 64 -> 128 -> 256 -> 512 -> 1024），效率提升巨大。

动态增长的数组（存储整数列表）

这个思想和字符串完全一样,只是数据类型从 char 变成了 int 或其他。

#include <stdio.h>
#include <stdlib.h>
typedef struct {
    int *data;      // 指向动态数组的指针
    size_t size;    // 当前元素个数
    size_t capacity;// 当前分配的容量
} IntVector;
// 初始化向量，预留初始容量
void int_vector_init(IntVector *vec, size_t initial_capacity) {
    vec->data = malloc(initial_capacity * sizeof(int));
    vec->size = 0;
    vec->capacity = initial_capacity;
}
// 向向量中添加元素，并在需要时预留空间
void int_vector_push_back(IntVector *vec, int value) {
    // 检查是否需要扩容
    if (vec->size >= vec->capacity) {
        // 容量翻倍
        vec->capacity *= 2;
        int *new_data = realloc(vec->data, vec->capacity * sizeof(int));
        if (!new_data) {
            // 内存分配失败，可以选择退出或处理错误
            // 这里简单打印错误并返回
            fprintf(stderr, "Failed to allocate memory!\n");
            return;
        }
        vec->data = new_data;
    }
    vec->data[vec->size++] = value;
}
// 释放向量内存
void int_vector_free(IntVector *vec) {
    free(vec->data);
    vec->data = NULL;
    vec->size = vec->capacity = 0;
}
int main() {
    IntVector my_vec;
    int_vector_init(&my_vec, 10); // 初始预留10个int的空间
    for (int i = 0; i < 25; ++i) {
        int_vector_push_back(&my_vec, i * i);
        printf("Added %d. Size: %zu, Capacity: %zu\n", i * i, my_vec.size, my_vec.capacity);
    }
    int_vector_free(&my_vec);
    return 0;
}

这个 IntVector 就是一个简单的 C 语言版“动态数组”，其核心就是 int_vector_push_back 函数中的预留空间逻辑。

总结与最佳实践

C 语言中的“预留空间”最佳实践：

1. 为动态数据结构（字符串、数组、链表节点池等）设计 capacity 字段，用于跟踪已分配的内存大小。
2. 选择一个合理的初始容量，避免从 1 开始，可以根据预估的平均数据量来设定。
3. 采用指数增长策略（通常是容量翻倍）来扩容，这是在时间和空间复杂度之间最好的折中。
4. 在添加数据前检查容量，size >= capacity，则触发扩容逻辑。
5. 使用 realloc 进行扩容，它会尝试在原地扩展内存块，如果不能，则会分配一块新内存并复制数据，最后释放旧内存。

虽然 C 语言没有 reserve 这个“魔法”函数，但通过手动实现上述逻辑，你可以获得同样甚至更好的性能和灵活性，理解并掌握这种思想是成为一名优秀 C 语言程序员的必备技能。