C语言多维数组指针传参疑问：单间接指针与int**的差异、变长数组架构限制及指针数组实现示例

咱们先从你遇到的警告说起，这俩警告本质上都是指针类型不匹配导致的：

1. 二维数组和int**根本不是一回事 #

你定义的int arr[][3]是一个连续存储的二维数组，在内存里它是把所有元素按行紧密排列的：1,2,3,4,5,6,7,8,9。当你把arr传给函数时，它会被隐式转换成指向数组首元素的指针，也就是int (*)[3]（指向一个包含3个int的数组的指针）。

而int**是指向指针的指针，它期望的是一个存储着int指针的数组（比如指针数组），和二维数组的内存布局完全不同。所以编译器会报错说“类型不兼容”——你把一个int (*)[3]塞给了需要int**的参数，这就像把苹果塞进橘子筐，肯定不对。

2. printf警告的原因 #

在第二个print函数里，*((arr+i*n)+j)的计算逻辑完全错了：

• arr是int**，arr+i*n是移动了i*n个指针的位置（每个指针占4/8字节），这和二维数组的连续内存布局完全不匹配；
• 解引用后得到的是int*类型，而printf("%d")需要的是int，所以类型不匹配，触发警告。

关于变长数组（VLA）的补充 #

你之前看到的“部分架构不支持VLA”是对的：C99标准引入了变长数组（允许用变量定义数组大小，比如int arr[m][n]），但有些编译器（比如微软的MSVC）直到现在都不完全支持C99的VLA特性，或者默认关闭了这个选项。如果你的代码要兼容这类编译器，就不能依赖VLA。

处理二维数组的其他方法 #

方法1：使用兼容的指针类型（最接近你的正确代码） #

把函数参数改成int*配合行列数计算（修正你第一个代码的参数遗漏问题）：

#include <stdio.h>
// 修正后的版本：传入m、n作为参数
void print(int *arr, int m, int n) {
    int i, j;
    for (i = 0; i < m; i++)
        for (j = 0; j < n; j++)
            printf("%d ", *(arr + i*n + j));
}
int main() {
    int arr[][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
    int m = 3, n = 3;
    print((int *)arr, m, n);
    return 0;
}

这里强制转换(int*)arr是把二维数组当成连续的一维数组来处理，通过i*n+j计算偏移量，完全符合它的内存布局。

方法2：使用变长数组（编译器支持时） #

如果你的编译器支持C99或更高版本的VLA，可以直接在函数参数里指定数组的大小，代码更直观：

#include <stdio.h>
// 注意：VLA参数要把m、n放在数组参数前面
void print(int m, int n, int arr[m][n]) {
    int i, j;
    for (i = 0; i < m; i++) {
        for (j = 0; j < n; j++) {
            printf("%d ", arr[i][j]);
        }
        printf("\n"); // 换行更清晰
    }
}
int main() {
    int arr[][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
    int m = 3, n = 3;
    print(m, n, arr);
    return 0;
}

这种方式不需要强制转换，编译器会自动处理数组的偏移。

方法3：用指针数组模拟二维数组 #

当然可以用指针数组实现类似的功能！不过要注意：指针数组的每一行可以指向不同的内存块（不一定连续），但如果要和你的原生二维数组功能一致，我们可以让指针数组的每个元素指向原生二维数组的每一行：

#include <stdio.h>
void print(int **arr, int m, int n) {
    int i, j;
    for (i = 0; i < m; i++) {
        for (j = 0; j < n; j++) {
            printf("%d ", arr[i][j]);
        }
        printf("\n");
    }
}
int main() {
    int arr[][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
    // 创建指针数组，指向arr的每一行
    int *ptr_arr[3] = {arr[0], arr[1], arr[2]};
    int m = 3, n = 3;
    // 现在ptr_arr是int**类型，可以直接传给print函数
    print(ptr_arr, m, n);
    return 0;
}

如果是动态分配的指针数组，也可以实现类似功能（适合处理大小不确定的数组）：

#include <stdio.h>
#include <stdlib.h>
void print(int **arr, int m, int n) {
    int i, j;
    for (i = 0; i < m; i++) {
        for (j = 0; j < n; j++) {
            printf("%d ", arr[i][j]);
        }
        printf("\n");
    }
}
int main() {
    int m = 3, n = 3;
    // 动态分配指针数组
    int **ptr_arr = malloc(m * sizeof(int*));
    for (int i = 0; i < m; i++) {
        // 动态分配每一行的内存
        ptr_arr[i] = malloc(n * sizeof(int));
        // 赋值
        for (int j = 0; j < n; j++) {
            ptr_arr[i][j] = i*n + j + 1;
        }
    }
    print(ptr_arr, m, n);
    // 记得释放内存
    for (int i = 0; i < m; i++) {
        free(ptr_arr[i]);
    }
    free(ptr_arr);
    return 0;
}

这种方式的好处是可以处理每行长度不同的“不规则”二维数组，缺点是内存可能不连续，动态分配时需要手动管理内存。

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