在 C 语言中，二维数组传递给被调用函数的方式取决于数组的声明方式与内存布局。**核心原则是：在函数形参中必须明确除第一维之外的所有维度大小，否则编译器无法正确计算偏移地址。**由于 C 语言的二维数组本质上是“按行连续存储的一维线性内存块”，函数传参时实际上是传递首地址，因此理解数组退化、指针类型匹配与内存排列规则，是正确使用二维数组函数参数的关键。

## 一、二维数组在 C 语言中的内存本质

在讲解二维数组如何传递给函数之前，必须先理解 C 语言中二维数组的本质。C 语言并不存在真正“多维”的底层结构，所谓二维数组本质上是**一维连续内存空间的规则映射**。例如 `int a[3][4];` 在内存中实际是 12 个连续的 `int` 元素。

二维数组在内存中的存储方式采用“按行优先（Row-major order）”排列，这意味着：

- 第 0 行的所有元素连续存储；
- 接着是第 1 行；
- 依次类推。

这种结构决定了数组元素的地址计算公式：

```c
a[i][j] = *( *(a + i) + j )
```

根据《The C Programming Language（Kernighan & Ritchie, 2nd Edition）》对数组与指针关系的说明，**数组名在表达式中会退化为指向首元素的指针**。对于二维数组而言，数组名退化为“指向一维数组的指针”，而不是“指向指针的指针”。

理解这一点，是掌握二维数组函数传参的前提。

## 二、二维数组作为函数参数的基本写法

在 C 语言中，将二维数组传递给函数时，必须明确指定列数。标准写法如下：

```c
void printArray(int arr[][4], int row);
```

或者：

```c
void printArray(int (*arr)[4], int row);
```

这两种写法在语义上是等价的。因为 `arr` 本质上是一个指向包含 4 个 `int` 元素数组的指针。

下面是完整示例：

```c
#include <stdio.h>

void printArray(int arr[][4], int row) {
    for(int i = 0; i < row; i++) {
        for(int j = 0; j < 4; j++) {
            printf("%d ", arr[i][j]);
        }
        printf("\n");
    }
}

int main() {
    int a[3][4] = {
        {1,2,3,4},
        {5,6,7,8},
        {9,10,11,12}
    };
    
    printArray(a, 3);
    return 0;
}
```

**关键点：必须明确列数 4，而行数可以省略。**

这是因为编译器需要通过列数计算每一行的内存跨度，否则无法正确定位元素。

## 三、为什么必须指定列数？原理解析

很多初学者疑问：为什么可以省略第一维，却不能省略第二维？

假设声明：

```c
void func(int arr[][]); // 错误
```

编译器会报错，因为它无法计算：

```
arr[i][j] = *(arr + i * ??? + j)
```

这里的 `???` 就是列数。如果不知道列数，就无法计算偏移量。

根据 ISO C 标准（ISO/IEC 9899:2018），数组下标访问在语义上等价于指针运算，而指针运算必须知道元素大小。对于二维数组来说，“元素”是一个一维数组，因此必须知道该数组大小。

我们可以用表格对比说明：

| 参数写法 | 是否合法 | 原因说明 |
|----------|----------|----------|
| int arr[][4] | ✅ 合法 | 列数明确，可计算偏移 |
| int arr[3][4] | ✅ 合法 | 行列都明确 |
| int arr[][] | ❌ 不合法 | 无法计算偏移 |
| int **arr | ❌ 类型不匹配 | 与二维数组结构不同 |

**结论：列数是二维数组传参时的核心信息。**

## 四、指针方式传递二维数组

除了 `arr[][4]` 写法，还可以使用指针形式：

```c
void func(int (*arr)[4]);
```

这里的 `(*arr)[4]` 表示：

- arr 是一个指针
- 指向包含 4 个 int 的数组

这是最本质的写法。

示例：

```c
void sumArray(int (*arr)[4], int row) {
    int sum = 0;
    for(int i = 0; i < row; i++) {
        for(int j = 0; j < 4; j++) {
            sum += arr[i][j];
        }
    }
    printf("sum = %d\n", sum);
}
```

这种写法在工程开发中更清晰，因为它直接表达了类型本质。

根据《C Primer Plus (6th Edition, Stephen Prata)》的解释，**二维数组名退化为“指向其第一行的指针”**，因此函数参数应匹配该类型。

## 五、使用宏定义提高通用性

当列数可能变化时，可以使用宏定义增强代码可维护性：

```c
#define COL 4

void printArray(int arr[][COL], int row);
```

这样修改列数时，只需修改宏定义。

| 方式 | 可维护性 | 可读性 | 推荐程度 |
|------|----------|--------|----------|
| 硬编码列数 | 低 | 一般 | 不推荐 |
| 宏定义列数 | 高 | 高 | ✅ 推荐 |
| 全局变量定义 | 中 | 一般 | 视情况 |

**宏方式是实际开发中较为规范的二维数组函数参数写法。**

## 六、动态二维数组如何传参

如果使用动态内存分配，如：

```c
int **arr;
```

这种结构和 `int a[3][4]` 本质不同。动态二维数组通常是“指针数组”，结构如下：

- 一级指针数组
- 每个元素指向一个一维数组

示例：

```c
int **arr = malloc(3 * sizeof(int *));
for(int i = 0; i < 3; i++) {
    arr[i] = malloc(4 * sizeof(int));
}
```

对应函数参数：

```c
void func(int **arr, int row, int col);
```

但这种方式与静态二维数组不兼容。

对比如下：

| 类型 | 内存结构 | 是否连续 | 参数类型 |
|------|----------|----------|----------|
| int a[3][4] | 连续 | ✅ | int (*arr)[4] |
| int **arr | 不一定连续 | ❌ | int **arr |

**两种二维数组不可混用。**

## 七、变长数组（VLA）传参方式

C99 标准（ISO/IEC 9899:1999）引入了变长数组（Variable Length Array, VLA），允许：

```c
void func(int row, int col, int arr[row][col]);
```

示例：

```c
void print(int row, int col, int arr[row][col]) {
    for(int i = 0; i < row; i++) {
        for(int j = 0; j < col; j++) {
            printf("%d ", arr[i][j]);
        }
        printf("\n");
    }
}
```

调用：

```c
int a[3][4];
print(3, 4, a);
```

这种方式更灵活，但需要编译器支持 C99 或以上标准。

根据 GCC 官方文档（GCC Manual, 2023），VLA 在 GNU C 中默认支持，但在某些嵌入式环境中可能禁用。

**优点是通用性强，缺点是兼容性依赖标准版本。**

## 八、常见错误与调试建议

在实际 C 语言开发中，二维数组函数传参常见错误包括：

第一，错误使用 `int **` 接收静态二维数组。

第二，忘记指定列数。

第三，传参维度不一致。

例如：

```c
int a[3][4];
void func(int arr[][5]); // 错误
```

编译器不会自动转换类型。

调试建议：

- 使用 `sizeof(arr[0])` 验证列大小；
- 使用 `printf("%p", arr);` 查看地址；
- 编译时开启 `-Wall` 警告选项。

**理解类型本质比记忆语法更重要。**

## 九、总结与未来趋势

综合来看，C 语言中二维数组传递给函数的核心规则是：**除第一维外，必须明确其他维度大小**。其本质源于数组在内存中的连续存储结构与指针偏移计算规则。无论使用传统静态数组、指针形式还是 C99 的变长数组，底层逻辑都遵循“行优先存储”和“指针运算”原则。

未来趋势方面，随着 C23 标准推进以及嵌入式与系统级开发对内存安全的关注提升，开发者更倾向于使用：

- 明确维度的类型声明；
- 静态分析工具检测数组越界；
- 更严格的编译器警告策略。

但无论标准如何演进，二维数组函数传参的核心原理不会改变，因为它根植于 C 语言最基础的内存模型。

只要掌握“数组退化”“指针类型匹配”“行优先存储”这三个关键词，就能彻底理解 C 语言中二维数组如何传递给被调用函数。

参考与资料来源  
1. Kernighan, B. W., & Ritchie, D. M. (1988). The C Programming Language (2nd Edition). Prentice Hall.  
2. ISO/IEC 9899:2018, Programming Languages — C.  
3. GCC Manual (2023), GNU Compiler Collection Documentation.

在C语言中，传递二维数组给函数时，参数应指定列数。例如，void func(int arr[][列数]) 或 void func(int (*arr)[列数])，列数需是常量或宏。行数可省略，因为指针运算依赖列数确定偏移。

二维数组作为函数参数的声明方式

在C语言中，函数如何声明参数以接收二维数组？需要注意哪些细节？

如何在函数参数中定义接收二维数组？

C语言中数组名作为函数参数实际上是指向数组首元素的指针，因此传递的是指向数组的指针，并非数组的完整拷贝。这样可减少内存开销，但需注意函数内部对数组元素的访问需基于对应的列数。

二维数组作为参数实为指针传递

二维数组作为参数传递时，函数接收到的数据是原数组的副本，还是指向原数组的指针？

传递二维数组给函数时，值传递还是指针传递？

函数内部访问二维数组需使用二维下标 arr[i][j]。传递二维数组时，列数必须已知且固定，否则访问会出错。确保传入的列数参数或以宏定义的列数相匹配，才能正确访问数组元素。

使用正确的下标访问以及列数信息

已经将二维数组传递给函数，函数内操作数组元素时应注意什么？

如何在函数内部访问传入的二维数组元素？

PingCodeDocs

在 C 语言中，二维数组传递给函数的关键在于必须明确除第一维之外的所有维度大小，否则编译器无法计算内存偏移。二维数组本质是按行连续存储的一维内存块，数组名在传参时会退化为指向首行的指针，因此函数形参应写为 int arr[][列数] 或 int (*arr)[列数]。动态分配的 int** 与静态二维数组结构不同，不能混用。理解数组退化、指针匹配与行优先存储原理，是正确传递二维数组的核心。

在c语言中二维数组如何传递给被调用函数

用户关注问题