如何在C语言中扩展数组大小且不丢失旧值？实现类似Python的append功能

嘿，我看到你在尝试用C实现类似Python append的数组扩展功能，但遇到了realloc后丢失原有值的问题——这其实是个常见的小错误，咱们一步步来解决它。

你的代码问题分析 #

先看你给出的代码片段：

int size_arr = 1; 
int *arr = (int *)malloc(sizeof(int)*size_arr); 
// 给数组第一个元素赋值为1
*(arr+0) = 1; 
size_arr++; 
// 使用realloc后丢失了*(arr+0)=1的值
arr = (int *)realloc(arr, size_arr);

问题出在**realloc的第二个参数上：realloc要求传入的是要分配的总字节数**，而不是元素个数。你现在size_arr是2，只分配了2个字节，但每个int通常占4个字节（取决于平台），这就导致分配的内存空间不足以容纳原有元素，进而引发未定义行为，表现为原有值丢失。

修正后的基础实现 #

要解决这个问题，我们需要修正realloc的参数，同时加上内存分配失败的检查（这是C语言内存管理的关键好习惯）：

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

int main() {
    int size_arr = 1; 
    // 分配初始内存，检查是否成功
    int *arr = (int *)malloc(sizeof(int) * size_arr); 
    if (arr == NULL) {
        perror("malloc failed");
        return 1;
    }
    
    // 给第一个元素赋值
    arr[0] = 1; 
    printf("扩展前 arr[0] = %d\n", arr[0]);

    size_arr++; 
    // 用临时变量接收realloc返回值，避免内存泄漏
    int *temp_arr = (int *)realloc(arr, sizeof(int) * size_arr);
    if (temp_arr == NULL) {
        perror("realloc failed");
        free(arr); // 释放原有内存，防止泄漏
        return 1;
    }
    arr = temp_arr; 

    printf("扩展后 arr[0] = %d\n", arr[0]);
    // 给新元素赋值
    arr[1] = 2;
    printf("新元素 arr[1] = %d\n", arr[1]);

    free(arr); // 记得释放内存
    return 0;
}

这里的核心要点：

• 用sizeof(int) * size_arr计算正确的总字节数，确保有足够空间容纳所有元素
• 用临时变量接收realloc的返回值：如果realloc失败返回NULL，直接赋值会丢失原有指针，造成内存泄漏
• 始终检查malloc和realloc的返回值，避免空指针操作

封装成类似Python append的动态数组 #

如果想更方便地使用类似Python列表的功能，可以封装一个动态数组结构体，把指针、元素长度、容量整合在一起：

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

// 定义动态数组结构体
typedef struct {
    int *data;
    int length;   // 当前元素个数
    int capacity; // 已分配的容量（元素数）
} DynamicArray;

// 初始化动态数组
DynamicArray* dyn_arr_init() {
    DynamicArray *arr = (DynamicArray*)malloc(sizeof(DynamicArray));
    if (arr == NULL) return NULL;
    arr->capacity = 1;
    arr->length = 0;
    arr->data = (int*)malloc(sizeof(int) * arr->capacity);
    if (arr->data == NULL) {
        free(arr);
        return NULL;
    }
    return arr;
}

// 追加元素（类似Python的append）
int dyn_arr_append(DynamicArray *arr, int value) {
    if (arr == NULL) return -1;
    // 容量不足时自动扩容（通常翻倍，减少realloc调用次数）
    if (arr->length == arr->capacity) {
        int new_capacity = arr->capacity * 2;
        int *temp_data = (int*)realloc(arr->data, sizeof(int) * new_capacity);
        if (temp_data == NULL) return -1;
        arr->data = temp_data;
        arr->capacity = new_capacity;
    }
    arr->data[arr->length] = value;
    arr->length++;
    return 0;
}

// 打印数组内容
void dyn_arr_print(DynamicArray *arr) {
    if (arr == NULL) return;
    for (int i = 0; i < arr->length; i++) {
        printf("%d ", arr->data[i]);
    }
    printf("\n");
}

// 销毁动态数组，释放内存
void dyn_arr_destroy(DynamicArray *arr) {
    if (arr == NULL) return;
    free(arr->data);
    free(arr);
}

int main() {
    DynamicArray *my_arr = dyn_arr_init();
    if (my_arr == NULL) {
        perror("init failed");
        return 1;
    }

    // 像Python一样追加元素
    dyn_arr_append(my_arr, 1);
    dyn_arr_append(my_arr, 2);
    dyn_arr_append(my_arr, 3);
    dyn_arr_append(my_arr, 4);

    printf("数组内容：");
    dyn_arr_print(my_arr); // 输出：1 2 3 4

    dyn_arr_destroy(my_arr);
    return 0;
}

这个封装的好处是：

• 把数组的状态（指针、长度、容量）统一管理，降低出错概率
• 自动扩容逻辑和Python列表类似，效率更高
• 提供完整的初始化、追加、销毁接口，使用起来更直观

内容的提问来源于stack exchange，提问作者user8660634