C语言二维数组的定义和使用（非常详细）

假设有一个名为 A 的一维数组，它包含了 10 个 int 类型的元素。另外，还有一个名为 B 的数组，它包含了 5 个元素，每个元素都是一个包含 10 个 int 元素的数组，如下图所示：


我们知道如何声明一个包含 10 个 int 元素的数组 A，即使用 int A[10]进行声明。那么，如何声明一个包含 5 个元素、每个元素都是一个包含 10 个 int 元素的数组 B 呢？

首先，让我们回顾数组的声明公式，如下图所示：


数组的声明包含了数组名、元素类型和元素数量三个要素。

现在，我们可以尝试声明一个名为 B 的数组，元素类型为 int[10]，元素数量为 5。根据上述公式，我们可以得出以下声明：

int[10] B[5];

但还需要将数组名左边的方括号都移到最右边：

int B[5][10];

这样，我们就成功地声明了一个名为 B 的数组，它包含了 5 个元素，每个元素都是一个包含 10 个 int 元素的数组，如下图所示。


通过使用数组名[下标]的形式，我们可以访问数组内的元素。例如，B[0]是数组 B 的第一个元素，而数组 B 的每个元素都是一个 int[10] 类型的数组，如下图所示。


要进一步访问数组 B[0] 中的 int 元素，我们需要使用 B[0][0] 这样的形式。这将访问第一个元素中的第一个元素，如下图所示：


我们可以看到，数组构成了一个二维的矩阵，并且可以通过下标轻松地访问它的每个元素。

二维数组的初始化

我们已经学习了如何初始化一维数组，例如：

int A[10] = {0, 1, 2, 3, 4, 5 ,6 ,7 ,8 ,9};

对于一个二维数组，由于它的每个元素都是一个数组，因此我们可以使用以下方式对它进行初始化：

int B[5][10] = {
    {0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
    {10, 11, 12, 13, 14, 15, 16, 17, 18, 19},
    {20, 21, 22, 23, 24, 25, 26, 27, 28, 29},
    {30, 31, 32, 33, 34, 35, 36, 37, 38, 39},
    {40, 41, 42, 43, 44, 45, 46, 47, 48, 49}
};

与一维数组相似，如果初始化列表中的常量个数少于元素个数，则剩余元素将使用 0 进行初始化：

int B[5][10] = {
    {0, 1, 2, 3, 4, 5},
    {10, 11, 12, 13, 14, 15},
    {20, 21, 22},
    {30},
    {0}
};

另外，我们也可以省略内层花括号，代码如下：

int B[5][10] ?= {
   0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
   10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
   20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
   30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
   40, 41, 42, 43, 44, 45, 46, 47, 48, 49
}

省略内层花括号时，如果元素的个数不足，那么后续的元素也将使用 0 进行初始化，代码如下：

int B[5][10] = {
    0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
    10, 11, 12, 13, 14, 15, 16, 17, 18, 19
}

访问二维数组

由于二维数组有两个下标，我们通常使用嵌套循环来遍历它。

下面是一个示例程序，它定义一个二维整型数组 B，其中包含 5 个一维数组，每个一维数组中有 10 个整数。

#include <stdio.h>

int main()
{
    int B[5][10] = {
        {0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
        {10, 11, 12, 13, 14, 15, 16, 17, 18, 19},
        {20, 21, 22, 23, 24, 25, 26, 27, 28, 29},
        {30, 31, 32, 33, 34, 35, 36, 37, 38, 39},
        {40, 41, 42, 43, 44, 45, 46, 47, 48, 49}
    };

    for(int i = 0; i < 5; i++)
    {
        for(int j = 0; j < 10; j++)
        {
            printf("%d ", B[i][j]);
        }
        printf("\n");
    }
    return 0;
}

我们使用了两个 for 循环遍历整个二维数组 B，外层循环控制行，内层循环控制列。对于每个数组元素，我们使用了 B[i][j] 的形式对其进行访问。运行结果为：

0 1 2 3 4 5 6 7 8 9
10 11 12 13 14 15 16 17 18 19
20 21 22 23 24 25 26 27 28 29
30 31 32 33 34 35 36 37 38 39
40 41 42 43 44 45 46 47 48 49

通过上述示例程序，我们可以看到如何遍历二维数组，并访问其中的每个元素。

修改二维数组元素

修改二维数组元素同样使用赋值运算符，代码如下：

B[i][j] = B[i][j] * 2;  //  修改二维数组值

下面是一个修改二维数组元素的示例，它将二维数组中的每个元素都设置为原来的 2 倍：

#include <stdio.h>

int main()
{
    int B[5][10] = {
        {0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
        {10, 11, 12, 13, 14, 15, 16, 17, 18, 19},
        {20, 21, 22, 23, 24, 25, 26, 27, 28, 29},
        {30, 31, 32, 33, 34, 35, 36, 37, 38, 39},
        {40, 41, 42, 43, 44, 45, 46, 47, 48, 49}
    };

    for(int i = 0; i < 5; i++)
    {
        for(int j = 0; j < 10; j++)
        {
            B[i][j] = B[i][j] * 2;    // 修改二维数组值
            printf("%d ", B[i][j]);  // 输出修改后的值
        }
        printf("\n");
    }
    return 0;
}

运行程序后，结果为：

0 2 4 6 8 10 12 14 16 18
20 22 24 26 28 30 32 34 36 38
40 42 44 46 48 50 52 54 56 58
60 62 64 66 68 70 72 74 76 78
80 82 84 86 88 90 92 94 96 98