Malloc内存覆盖问题：从文件提取数据至动态数组失败求助

核心问题大概率是你没有为每个字段单独分配持久化内存，或者数组本身未做动态扩容导致越界覆盖。以下是可直接复用的实现思路和代码，完全规避全局变量，同时保证每个数组的内存独立不被覆盖：

1. 用结构体封装四个动态数组 #

把四个数组打包成结构体，方便从函数返回，避免多指针传递的混乱：

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

// 封装四个动态数组及状态
typedef struct {
    char** ids;
    char** titles;
    char** names;
    char** dates;
    size_t count;    // 当前存储的元素数量
    size_t capacity; // 数组的总容量（避免频繁扩容）
} ConferenceData;

2. 初始化结构体与动态扩容逻辑 #

先给数组分配初始容量，当元素数量达到容量时，按2倍扩容：

// 初始化结构体，分配初始容量
ConferenceData* init_conference_data(size_t initial_capacity) {
    ConferenceData* data = malloc(sizeof(ConferenceData));
    if (!data) return NULL;

    data->count = 0;
    data->capacity = initial_capacity;

    // 为每个数组分配初始指针空间
    data->ids = malloc(sizeof(char*) * initial_capacity);
    data->titles = malloc(sizeof(char*) * initial_capacity);
    data->names = malloc(sizeof(char*) * initial_capacity);
    data->dates = malloc(sizeof(char*) * initial_capacity);

    if (!data->ids || !data->titles || !data->names || !data->dates) {
        // 分配失败则释放已分配的内存
        free(data->ids);
        free(data->titles);
        free(data->names);
        free(data->dates);
        free(data);
        return NULL;
    }
    return data;
}

// 动态扩容数组
int resize_conference_data(ConferenceData* data) {
    size_t new_capacity = data->capacity * 2;
    // 重新分配每个数组的指针空间
    char** new_ids = realloc(data->ids, sizeof(char*) * new_capacity);
    char** new_titles = realloc(data->titles, sizeof(char*) * new_capacity);
    char** new_names = realloc(data->names, sizeof(char*) * new_capacity);
    char** new_dates = realloc(data->dates, sizeof(char*) * new_capacity);

    if (!new_ids || !new_titles || !new_names || !new_dates) {
        // 扩容失败则回退，避免内存泄漏
        free(new_ids);
        free(new_titles);
        free(new_names);
        free(new_dates);
        return 0;
    }

    data->ids = new_ids;
    data->titles = new_titles;
    data->names = new_names;
    data->dates = new_dates;
    data->capacity = new_capacity;
    return 1;
}

3. 读取文件并拆分字段到数组 #

关键：每个字段必须单独用malloc分配内存，不能直接指向栈上的临时缓冲区（这是导致数据被覆盖的常见原因）：

// 读取文件并填充数据
ConferenceData* read_conference_file(const char* filename) {
    FILE* fp = fopen(filename, "r");
    if (!fp) return NULL;

    // 初始容量设为8，可根据实际调整
    ConferenceData* data = init_conference_data(8);
    if (!data) {
        fclose(fp);
        return NULL;
    }

    char line[1024]; // 临时存储每行内容，假设单行不超过1024字节
    while (fgets(line, sizeof(line), fp)) {
        // 移除换行符
        line[strcspn(line, "\n")] = '\0';

        // 拆分字段（假设字段用逗号分隔，可根据实际分隔符修改）
        char* id = strtok(line, ",");
        char* title = strtok(NULL, ",");
        char* name = strtok(NULL, ",");
        char* date = strtok(NULL, ",");

        if (!id || !title || !name || !date) continue; // 跳过格式错误的行

        // 检查是否需要扩容
        if (data->count >= data->capacity) {
            if (!resize_conference_data(data)) {
                // 扩容失败，清理已分配内存
                free_conference_data(data);
                fclose(fp);
                return NULL;
            }
        }

        // 为每个字段单独分配内存，复制内容
        data->ids[data->count] = malloc(strlen(id) + 1);
        strcpy(data->ids[data->count], id);

        data->titles[data->count] = malloc(strlen(title) + 1);
        strcpy(data->titles[data->count], title);

        data->names[data->count] = malloc(strlen(name) + 1);
        strcpy(data->names[data->count], name);

        data->dates[data->count] = malloc(strlen(date) + 1);
        strcpy(data->dates[data->count], date);

        data->count++;
    }

    fclose(fp);
    return data;
}

4. 内存释放函数 #

必须递归释放每个字段的内存，再释放数组和结构体：

// 释放所有内存
void free_conference_data(ConferenceData* data) {
    if (!data) return;

    for (size_t i = 0; i < data->count; i++) {
        free(data->ids[i]);
        free(data->titles[i]);
        free(data->names[i]);
        free(data->dates[i]);
    }

    free(data->ids);
    free(data->titles);
    free(data->names);
    free(data->dates);
    free(data);
}

5. main函数调用示例 #

int main() {
    ConferenceData* conf_data = read_conference_file("konferencnyZoznam");
    if (!conf_data) {
        printf("读取文件失败\n");
        return 1;
    }

    // 使用四个数组，示例：打印第一个元素
    if (conf_data->count > 0) {
        printf("ID: %s\n", conf_data->ids[0]);
        printf("Title: %s\n", conf_data->titles[0]);
        printf("Name: %s\n", conf_data->names[0]);
        printf("Date: %s\n", conf_data->dates[0]);
    }

    // 用完后释放内存
    free_conference_data(conf_data);
    return 0;
}

关键注意事项 #

• 禁止直接指向临时缓冲区：比如不能把strtok返回的指针直接存到数组里，因为strtok操作的是栈上的line数组，下一次循环会覆盖内容，必须用malloc+strcpy复制一份。
• 数组扩容要同步：四个数组的容量要保持一致，避免某个数组越界。
• 内存泄漏检查：所有malloc的内存都要对应free，包括每个字段和数组本身。

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