如何根据用户输入在运行时分配C语言指定维度的多维数组？

嘿，这个问题问得特别实际——毕竟静态多维数组的第一维虽然能省略，但大小是编译时就固定死的，要在运行时根据用户输入动态分配，得换用动态内存的思路。我给你分二维、三维两种场景拆解，都是C语言里常用的靠谱方案：

一、先搞定二维数组的动态分配（比如你举的int arr[][3]，第二维固定） #

这里有两种主流实现方式，各有优劣：

方法1：用指针数组分步分配（直观易理解） #

这种方式先分配一个存储行指针的数组，再给每个指针单独分配对应列数的内存块，逻辑很清晰：

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

int main() {
    int rows;
    printf("输入第一维大小：");
    scanf("%d", &rows);
    const int cols = 3; // 对应你例子里固定的第二维

    // 第一步：分配存储行指针的数组，每个元素是int*类型
    int **arr = (int**)malloc(rows * sizeof(int*));
    if (arr == NULL) {
        perror("malloc失败");
        return 1;
    }

    // 第二步：给每一行分配固定列数的内存
    for (int i = 0; i < rows; i++) {
        arr[i] = (int*)malloc(cols * sizeof(int));
        if (arr[i] == NULL) {
            perror("malloc失败");
            // 必须释放已分配的内存，避免泄漏
            for (int j = 0; j < i; j++) {
                free(arr[j]);
            }
            free(arr);
            return 1;
        }
    }

    // 现在可以像静态数组一样用arr[i][j]访问
    arr[0][0] = 1; arr[0][1] = 2; arr[0][2] = 3;
    arr[1][0] = 4; arr[1][1] = 5; arr[1][2] = 6;

    // 释放内存要分步：先释放每一行，再释放指针数组
    for (int i = 0; i < rows; i++) {
        free(arr[i]);
    }
    free(arr);

    return 0;
}

注意：这种方式的内存不是连续的，每行是单独的内存块，好处是灵活，坏处是缓存友好性稍差，释放时要多一步操作。

方法2：分配连续内存块，模拟二维数组（高效推荐） #

如果想要和静态数组完全一致的连续内存布局，直接分配rows * cols大小的一维数组，再用行指针类型转换来模拟二维访问：

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

int main() {
    int rows;
    printf("输入第一维大小：");
    scanf("%d", &rows);
    const int cols = 3;

    // 直接分配连续内存块，大小是rows个int[cols]
    int (*arr)[cols] = (int(*)[cols])malloc(rows * sizeof(*arr));
    if (arr == NULL) {
        perror("malloc失败");
        return 1;
    }

    // 同样用arr[i][j]访问，内存连续，缓存效率更高
    arr[0][0] = 1; arr[0][1] = 2; arr[0][2] = 3;
    arr[1][0] = 4; arr[1][1] = 5; arr[1][2] = 6;

    // 释放时直接free(arr)就行，因为是整块内存
    free(arr);

    return 0;
}

这里int (*arr)[cols]是指向int[cols]的行指针，只要编译器支持C99及以上（现在大部分主流编译器都支持），这种方式是最优解。

二、再处理三维数组的动态分配（比如int arr[][M][N]，M、N固定） #

思路和二维的方法2一致，用指向二维数组的指针来分配连续内存。假设M=10、N=15是固定值：

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

#define M 10
#define N 15

int main() {
    int depth;
    printf("输入第一维大小：");
    scanf("%d", &depth);

    // 定义指向int[M][N]的指针，分配depth个这样的二维数组
    int (*arr)[M][N] = (int(*)[M][N])malloc(depth * sizeof(*arr));
    if (arr == NULL) {
        perror("malloc失败");
        return 1;
    }

    // 访问方式和静态三维数组完全一致：arr[d][i][j]
    arr[0][0][0] = 100;
    arr[2][5][10] = 200;

    // 直接释放整块内存即可
    free(arr);

    return 0;
}

这种方式同样保证内存连续，和静态三维数组布局完全相同，访问效率拉满。

额外小提醒：关于变长数组（VLA） #

如果你的编译器支持C99，也可以直接用变长数组在栈上分配，但要注意栈的容量有限（一般只有几MB），如果第一维数值太大，很容易栈溢出，只适合小容量场景：

int rows;
scanf("%d", &rows);
const int cols = 3;
int arr[rows][cols]; // 这就是变长数组，运行时确定rows大小

所以如果是大容量数组，还是优先用malloc在堆上动态分配更安全。

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