如何存储不同行列尺寸的多组3D数组并避免数据覆盖？

问题 #

需要创建并管理多个维度不同的矩阵（比如0×2×2、1×1×3这类），每个矩阵的行列数都不固定，且要保证后续能正常访问所有矩阵的数据，不会被覆盖。

原方案的问题 #

之前尝试在循环内定义包含二维变长数组的结构体，再用结构体数组存储，但每次循环重新定义结构体时，会改变结构体的大小，导致之前存储的数据被覆盖；同时循环内的局部数组会在循环结束后销毁，后续访问会触发未定义行为。

原代码问题分析 #

int main()
{
 int matrix;
 printf("ENTER NUMBER OF MATRICES\n");
 scanf("%d`", &matrix); // 语法错误：%d后多了个`
 int row, column;


for (int m = 0; m < matrix; m++) {
    printf("ENTER NUMBER OF ROWS IN %d MATRICE\n", m + 1);
    scanf("%d", &row);
    printf("ENTER NUMBER OF column IN %d MATRICE\n", m + 1);
    scanf("%d", &column);
     struct x {
  int f[row][column];
};
    struct x k[m]; // 局部变长数组，循环结束后内存销毁，且索引k[m]越界
    int g = 1;

    printf("ENTER ALL ELEMENT LEFT TO RIGHT\n");
    for (int j = 0; j < row; j++) {
        
        for (int u = 0; u < column; u++) {
            
            printf("%d)\n", g);
            scanf("%d", &k[m].f[j][u]); // 数组越界：k长度为m，最大索引是m-1
            g = g + 1;
        }
    }
    for (int s = 0; s < row; s++) {
        printf("|");
        for (int l = 0; l < column; l++) {
             
            printf("%d", k[m].f[s][l]);
            if (l < column - 1) {
                printf("  ");
                
            }
        }
        printf("|\n");
        
    }
    printf("%d", k[0].f[0][0]); // 访问已销毁的局部数组，行为未定义
 }
  return 0;
}

原代码核心错误：

• 循环内定义的struct x每次类型都不同（依赖row和column的变量值），无法统一存储。
• 局部变长数组k[m]生命周期仅在当前循环迭代，迭代结束后内存被回收，后续访问属于非法操作。
• k[m]存在数组越界问题，访问了超出数组长度的索引。

改进方案：动态内存分配+统一结构体 #

使用动态分配内存的方式，定义包含行列数和二维数组指针的结构体，统一管理所有矩阵，确保每个矩阵的内存独立且持久。

改进后代码 #

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

// 定义统一的矩阵结构体，包含行列数和动态分配的二维数组指针
typedef struct {
    int rows;
    int cols;
    int **data;
} Matrix;

int main() {
    int matrix_count;
    printf("ENTER NUMBER OF MATRICES\n");
    // 修正输入错误判断
    if (scanf("%d", &matrix_count) != 1 || matrix_count < 0) {
        printf("输入无效\n");
        return 1;
    }
    
    // 动态分配存储所有矩阵的数组
    Matrix *matrices = malloc(matrix_count * sizeof(Matrix));
    if (matrices == NULL) {
        printf("内存分配失败\n");
        return 1;
    }
    
    for (int m = 0; m < matrix_count; m++) {
        int rows, cols;
        printf("ENTER NUMBER OF ROWS IN %d MATRICE\n", m + 1);
        if (scanf("%d", &rows) != 1 || rows < 0) {
            printf("输入无效\n");
            goto cleanup;
        }
        printf("ENTER NUMBER OF column IN %d MATRICE\n", m + 1);
        if (scanf("%d", &cols) != 1 || cols < 0) {
            printf("输入无效\n");
            goto cleanup;
        }
        
        // 初始化当前矩阵的行列信息
        matrices[m].rows = rows;
        matrices[m].cols = cols;
        
        // 动态分配行指针数组
        matrices[m].data = malloc(rows * sizeof(int*));
        if (matrices[m].data == NULL) {
            printf("内存分配失败\n");
            goto cleanup;
        }
        
        // 动态分配每行的列数据
        for (int j = 0; j < rows; j++) {
            matrices[m].data[j] = malloc(cols * sizeof(int));
            if (matrices[m].data[j] == NULL) {
                printf("内存分配失败\n");
                goto cleanup;
            }
        }
        
        // 输入矩阵元素
        int g = 1;
        printf("ENTER ALL ELEMENT LEFT TO RIGHT\n");
        for (int j = 0; j < rows; j++) {
            for (int u = 0; u < cols; u++) {
                printf("%d)\n", g);
                scanf("%d", &matrices[m].data[j][u]);
                g++;
            }
        }
        
        // 打印当前矩阵
        for (int s = 0; s < rows; s++) {
            printf("|");
            for (int l = 0; l < cols; l++) {
                printf("%d", matrices[m].data[s][l]);
                if (l < cols - 1) {
                    printf("  ");
                }
            }
            printf("|\n");
        }
        
        // 验证第一个矩阵的数据未被覆盖
        if (m >= 0) {
            printf("第一个矩阵的[0][0]元素：%d\n", matrices[0].data[0][0]);
        }
    }

cleanup:
    // 释放所有动态分配的内存，避免泄漏
    for (int i = 0; i < matrix_count; i++) {
        if (matrices[i].data != NULL) {
            for (int j = 0; j < matrices[i].rows; j++) {
                free(matrices[i].data[j]);
            }
            free(matrices[i].data);
        }
    }
    free(matrices);
    
    return 0;
}

方案说明 #

1. 统一结构体类型：Matrix结构体包含行列数和二维数组指针，所有矩阵都用这个类型存储，保证类型一致。
2. 动态内存分配：每个矩阵的行和列都通过malloc动态分配，内存独立于循环作用域，不会被后续迭代覆盖。
3. 内存安全处理：添加了内存分配失败的判断和内存释放逻辑，避免内存泄漏和非法访问。
4. 避免越界：通过结构体存储的行列数控制循环边界，确保访问数组时不会越界。

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