嵌套含Union的结构体动态内存分配释放报错排查

看起来你遇到的核心问题是动态扩容时的浅拷贝导致重复释放内存，同时可能伴随内存访问或初始化的疏漏。咱们一步步拆解问题，找到针对性的解决方案：

问题根源分析 #

你的Content结构体嵌套了union，其中SellItem持有动态分配的char **image_files数组。当你用realloc扩容Content数组时，如果只是直接赋值Content元素（比如new_array[i] = old_array[i]），这属于浅拷贝——新旧数组里的SellItem会共享同一个image_files指针。当释放内存时，同一块内存会被两次free，直接触发double free or corruption错误。

另外，打印时的异常大概率也是内存管理不当导致的：比如访问了未正确初始化的union成员，或者动态内存分配不完整引发野指针。

解决方案步骤 #

1. 实现深拷贝的扩容逻辑 #

increase函数不能只依赖realloc完成内存扩容，还要对每个Content元素做深拷贝，尤其是SellItem里的动态内存：

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

// 深拷贝单个SellItem
void copy_sell_item(struct SellItem *dest, const struct SellItem *src) {
    // 拷贝固定长度字段
    strncpy(dest->title, src->title, sizeof(dest->title)-1);
    dest->title[sizeof(dest->title)-1] = '\0';
    strncpy(dest->description, src->description, sizeof(dest->description)-1);
    dest->description[sizeof(dest->description)-1] = '\0';
    dest->price = src->price;
    dest->nr_of_img = src->nr_of_img;
    
    // 深拷贝image_files数组
    dest->image_files = malloc(sizeof(char*) * src->nr_of_img);
    if (dest->image_files == NULL) {
        perror("malloc image_files failed");
        exit(EXIT_FAILURE);
    }
    for (int i = 0; i < src->nr_of_img; i++) {
        dest->image_files[i] = strdup(src->image_files[i]);
        if (dest->image_files[i] == NULL) {
            perror("strdup image path failed");
            // 出错时回滚已分配的内存
            for (int j = 0; j < i; j++) free(dest->image_files[j]);
            free(dest->image_files);
            exit(EXIT_FAILURE);
        }
    }
}

// 深拷贝单个Content元素
void copy_content(struct Content *dest, const struct Content *src) {
    dest->type = src->type;
    if (src->type == 1) { // 处理SellItem类型
        copy_sell_item(&dest->c_item.s_item, &src->c_item.s_item);
    } else if (src->type == 2) { // 处理ParagraphItem类型
        dest->c_item.p_item.text = strdup(src->c_item.p_item.text);
        if (dest->c_item.p_item.text == NULL) {
            perror("strdup paragraph text failed");
            exit(EXIT_FAILURE);
        }
    }
}

// 正确的扩容函数
struct Content* increase(struct Content *old_array, int *current_size) {
    int new_size = *current_size + 1;
    // 先申请新内存，避免realloc失败丢失原指针
    struct Content *new_array = realloc(old_array, sizeof(struct Content) * new_size);
    if (new_array == NULL) {
        perror("realloc failed");
        return old_array; // 原数组仍然有效，返回原指针
    }
    
    *current_size = new_size;
    return new_array;
}

2. 严格的内存释放流程 #

释放内存时必须遵循先内后外的顺序：先遍历Content数组，根据type释放每个元素内部的动态内存，最后再释放Content数组本身：

void free_content_array(struct Content *array, int size) {
    for (int i = 0; i < size; i++) {
        if (array[i].type == 1) { // 释放SellItem的动态资源
            struct SellItem *item = &array[i].c_item.s_item;
            if (item->image_files != NULL) {
                for (int j = 0; j < item->nr_of_img; j++) {
                    free(item->image_files[j]);
                }
                free(item->image_files);
            }
        } else if (array[i].type == 2) { // 释放ParagraphItem的动态资源
            free(array[i].c_item.p_item.text);
        }
    }
    // 最后释放数组本身
    free(array);
}

3. 初始化第三个元素的正确姿势 #

添加第三个SellItem时，要确保它的image_files是全新分配的，绝对不能复用其他元素的指针：

int main() {
    int size = 2;
    struct Content *content_array = malloc(sizeof(struct Content) * size);
    // 初始化前两个测试元素...
    
    // 扩容数组
    content_array = increase(content_array, &size);
    // 初始化第三个SellItem
    struct Content *new_item = &content_array[2];
    new_item->type = 1;
    strncpy(new_item->c_item.s_item.title, "Third Handphone", sizeof(new_item->c_item.s_item.title)-1);
    new_item->c_item.s_item.price = 1299;
    new_item->c_item.s_item.nr_of_img = 3;
    // 分配并初始化image_files
    new_item->c_item.s_item.image_files = malloc(sizeof(char*) * 3);
    new_item->c_item.s_item.image_files[0] = strdup("phone_front.jpg");
    new_item->c_item.s_item.image_files[1] = strdup("phone_back.jpg");
    new_item->c_item.s_item.image_files[2] = strdup("phone_side.jpg");
    
    // 打印测试（确保只访问对应type的union成员）
    for (int i = 0; i < size; i++) {
        if (content_array[i].type == 1) {
            printf("Item %d: %s, Price: %d\n", i+1, content_array[i].c_item.s_item.title, content_array[i].c_item.s_item.price);
        } else if (content_array[i].type == 2) {
            printf("Paragraph %d: %s\n", i+1, content_array[i].c_item.p_item.text);
        }
    }
    
    // 释放所有内存
    free_content_array(content_array, size);
    return 0;
}

4. 打印异常的排查要点 #

如果打印时仍有错误，检查以下两点：

• 确保访问union成员时，type标记完全匹配（比如type=1时只访问s_item，type=2时只访问p_item），避免读取未初始化的union成员导致垃圾数据。
• 确保image_files里的字符串都是以\0结尾的，避免打印时越界读取内存。

关键注意点总结 #

• 深拷贝是核心：当结构体包含动态分配的内存时，必须用深拷贝，避免多个指针共享同一块内存。
• realloc要防丢指针：永远不要直接把realloc的结果赋值给原指针，否则如果realloc失败，原内存块会丢失，引发内存泄漏。
• 释放顺序不能乱：先释放结构体内部的动态内存，再释放结构体数组本身，顺序颠倒会导致野指针或重复释放。

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