在 C 语言中，数组长度是固定的，但可以通过 动态内存管理 实现类似“扩展数组长度”的效果。以下是两种常见方法：

方法 1：使用realloc直接扩展

通过 realloc 函数重新分配更大的内存空间，并将原数据复制到新内存中。

#include 
#include 

// 扩展数组长度（返回新指针）
int* expandArray(int* arr, int oldSize, int newSize) {
    if (newSize <= oldSize) return arr; // 新大小必须大于旧大小

    // 重新分配内存（新内存未初始化）
    int* newArr = (int*)realloc(arr, newSize * sizeof(int));
    if (newArr == NULL) {
        fprintf(stderr, "Memory allocation failed\n");
        free(arr); // 释放原内存避免泄漏
        exit(EXIT_FAILURE);
    }

    // 可选：初始化新增部分（例如置零）
    for (int i = oldSize; i < newSize; i++) {
        newArr[i] = 0;
    }

    return newArr;
}

// 示例用法
int main() {
    int oldSize = 5;
    int* arr = (int*)malloc(oldSize * sizeof(int));
    for (int i = 0; i < oldSize; i++) arr[i] = i;

    // 扩展数组到新大小
    int newSize = 10;
    arr = expandArray(arr, oldSize, newSize);

    // 验证扩展结果
    for (int i = 0; i < newSize; i++) {
        printf("%d ", arr[i]); // 0 1 2 3 4 0 0 0 0 0
    }

    free(arr); // 最终释放内存
    return 0;
}

关键点：

• realloc 可能返回新地址，需重新赋值指针。
• 若 realloc 失败，需手动释放原内存避免泄漏。
• 扩展后的新增区域默认包含未初始化的数据，建议手动初始化。

方法 2：封装动态数组结构体

通过结构体管理动态数组的长度、容量和元素，实现自动扩展（类似 C++ 的 vector）。

#include 
#include 

// 动态数组结构体
typedef struct {
    int* data;      // 数据指针
    int size;       // 当前元素数量
    int capacity;   // 总容量
} DynamicArray;

// 初始化动态数组
DynamicArray* createDynamicArray(int initialCapacity) {
    DynamicArray* da = (DynamicArray*)malloc(sizeof(DynamicArray));
    da->data = (int*)malloc(initialCapacity * sizeof(int));
    da->size = 0;
    da->capacity = initialCapacity;
    return da;
}

// 扩展容量（按需调用）
void expandCapacity(DynamicArray* da, int newCapacity) {
    if (newCapacity <= da->capacity) return;

    int* newData = (int*)realloc(da->data, newCapacity * sizeof(int));
    if (newData == NULL) {
        fprintf(stderr, "Memory allocation failed\n");
        free(da->data);
        free(da);
        exit(EXIT_FAILURE);
    }
    da->data = newData;
    da->capacity = newCapacity;
}

// 添加元素（自动扩展）
void addElement(DynamicArray* da, int value) {
    if (da->size >= da->capacity) {
        // 扩展策略：容量翻倍（常见优化）
        expandCapacity(da, da->capacity * 2);
    }
    da->data[da->size++] = value;
}

// 释放内存
void destroyDynamicArray(DynamicArray* da) {
    free(da->data);
    free(da);
}

// 示例用法
int main() {
    DynamicArray* da = createDynamicArray(2); // 初始容量 2

    // 添加元素（触发自动扩展）
    addElement(da, 10);
    addElement(da, 20);
    addElement(da, 30); // 容量扩展为 4

    printf("Elements: ");
    for (int i = 0; i < da->size; i++) {
        printf("%d ", da->data[i]); // 10 20 30
    }

    destroyDynamicArray(da);
    return 0;
}

关键点：

• 容量扩展策略：通常按倍数增长（如翻倍），均摊时间复杂度为 O(1)。
• 自动管理：添加元素时检查容量，不足时自动扩展。
• 内存安全：使用后需调用销毁函数释放内存。

注意事项

1. 内存泄漏：

• 确保每次 malloc/realloc 后都有对应的 free。
• 使用 valgrind 等工具检测内存问题。

2. 错误处理：

• 检查 malloc/realloc 返回值是否为 NULL。
• 在扩展失败时，需释放原有内存避免泄漏。

3. 性能优化：

• 避免频繁扩展（如每次扩展 1 个元素），推荐按倍数增长。
• 初始化时根据场景选择合理的初始容量。

通过上述方法，可以在 C 语言中实现类似动态数组的功能，灵活管理内存并扩展数组长度。