C语言模拟Python列表时数组出现随机值的问题修复

问题根源 #

你的代码存在三个核心问题，导致出现随机值和错误长度：

• 静态数组大小固定：int myNumbers[] 是栈上分配的固定长度数组，初始化后大小就固定为初始元素的个数。执行push时往length索引赋值，本质是越界访问不属于数组的内存区域，属于未定义行为。
• 长度计算依赖元素值：len函数通过判断arr[i] != '\0'（即元素为0）来终止计数，但如果数组中没有0元素，会一直读取内存中的随机数据，直到偶然碰到0为止，导致长度计算错误。
• 遍历循环条件错误：for(int i = 0; myNumbers[i]; i++) 同样依赖元素非0来终止循环，和长度计算的问题一致，会读到越界的随机值。

修复方案 #

要模拟Python列表的动态扩容特性，必须使用动态内存分配，并封装数组的长度和容量信息。具体实现如下：

1. 定义封装动态数组的结构体（头文件 l.h） #

#ifndef L_H
#define L_H

// 封装动态数组的结构体，模拟Python列表
typedef struct {
    int* data;       // 存储元素的动态内存指针
    int length;      // 当前元素数量
    int capacity;    // 已分配的内存容量（可容纳的最大元素数）
} List;

// 初始化一个空列表，初始容量可自定义
List* list_init(int initial_capacity);

// 获取列表长度
int list_len(List* list);

// 向列表末尾添加元素
void list_push(List* list, int value);

// 销毁列表，释放内存
void list_destroy(List* list);

#endif

2. 实现列表操作函数（l.c） #

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

List* list_init(int initial_capacity) {
    List* list = malloc(sizeof(List));
    if (!list) {
        fprintf(stderr, "内存分配失败\n");
        exit(1);
    }
    list->data = malloc(sizeof(int) * initial_capacity);
    if (!list->data) {
        free(list);
        fprintf(stderr, "内存分配失败\n");
        exit(1);
    }
    list->length = 0;
    list->capacity = initial_capacity;
    return list;
}

int list_len(List* list) {
    printf("Length is: %d\n", list->length);
    return list->length;
}

void list_push(List* list, int value) {
    // 如果当前长度等于容量，扩容（这里按2倍扩容，可自定义）
    if (list->length == list->capacity) {
        int new_capacity = list->capacity * 2;
        int* new_data = realloc(list->data, sizeof(int) * new_capacity);
        if (!new_data) {
            fprintf(stderr, "内存扩容失败\n");
            exit(1);
        }
        list->data = new_data;
        list->capacity = new_capacity;
    }
    // 添加新元素
    list->data[list->length] = value;
    list->length++;
}

void list_destroy(List* list) {
    free(list->data);
    free(list);
}

3. 主函数测试（list.c） #

#include <stdio.h>
#include "l.h"

int main() {
    // 初始化一个初始容量为5的列表
    List* myNumbers = list_init(5);
    
    // 添加初始元素
    list_push(myNumbers, 25);
    list_push(myNumbers, 50);
    list_push(myNumbers, 75);
    list_push(myNumbers, 100);
    list_push(myNumbers, 125);
    
    // 添加新元素
    list_push(myNumbers, 200);
    
    // 遍历列表（用存储的length控制循环）
    for (int i = 0; i < myNumbers->length; i++) {
        printf("array[%d] = %d\n", i, myNumbers->data[i]);
    }
    
    // 再次获取长度
    list_len(myNumbers);
    
    // 销毁列表，避免内存泄漏
    list_destroy(myNumbers);

    return 0;
}

运行结果 #

执行上述代码后，会得到你期望的输出：

Length is: 5
array[0] = 25
array[1] = 50
array[2] = 75
array[3] = 100
array[4] = 125
array[5] = 200
Length is: 6

关键说明 #

• 用结构体封装data指针、length和capacity，彻底解决了静态数组大小固定的问题。
• list_push函数会自动检查容量，不足时通过realloc扩容，保证不会越界。
• 长度计算和遍历都依赖存储的length值，不再依赖元素是否为0，避免了随机值问题。

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