C，多维数组：其元素是一维数组的数组？

Question

从第269页的C Programming: A Modern Approach, 2nd Edition这本书开始，这种说法有意义吗

  

就像一维数组的名称可以用作指针一样， any 数组的名称也可以用作指针，而不管它有多少维。但是，需要小心。考虑以下数组：

source ./Scripts/activate

     

int a[NUM_ROWS][NUM_COLS]; 不是指向a的指针，而是指向a[0][0];的指针。 如果从C的角度来看它，这将更有意义，因为C将a[0]视为不是二维数组，而是将其视为一维数组的一维数组。当用作指针时，a的类型为a（指向长度为int (*) [NUM_COLS]的整数数组的指针）。

我很困惑，因为当我想到“其元素是一维数组的数组” 时，我认为是jagged-array，但这不是这里要发生的事情。有指针算术的宏？

这是关于类型系统的参考，以及它如何处理多维数组？有人可以解释吗？

Answer 1

是的，这是有道理的，不是，它甚至不是在谈论“参差不齐”或“参差不齐”的数组。只是当我们说

int a[NUM_ROWS][NUM_COLS];

我们正在创建的是一个数组a，而它是一个数组...其他数组。您可以这样想：

        +---------------------------------------+
        | +--------+--------+--------+--------+ |
a: [0]: | |        |        |        |        | |
        | +--------+--------+--------+--------+ |
        +                                       +
        | +--------+--------+--------+--------+ |
   [1]: | |        |        |        |        | |
        | +--------+--------+--------+--------+ |
        +                                       +
        | +--------+--------+--------+--------+ |
   [2]: | |        |        |        |        | |
        | +--------+--------+--------+--------+ |
        +---------------------------------------+

（这里NUM_COLS显然是4，而NUM_ROWS是3。）

二维（或更多）二维数组与简单的单维数组100％相似-您只需要仔细考虑这些相似之处即可。如果a是一个数组，则在需要其值的表达式中对a的任何提及都会导致指向数组第一个元素&a[0]的指针。因此，考虑到我们要讨论的二维数组a，a的值是&a[0]，它是指向NUM_COLS整数数组的指针< / em>。

如果多维数组下标要正常工作，则必须以这种方式工作。如果我们写a[i][j]，则解释为(a[i])[j]。像往常一样，a变成了指向数组第一个元素的指针，但是a[i]等效于*(a + i)，其中指针算术最终被指向的元素的大小缩放-也就是说，它更像*(a+ i * sizeof(*a))。因此sizeof(*a)必须是sizeof(int [NUM_COLS])或NUM_COLS * sizeof(int)。这样，a[i]将使您获得第i个子数组，然后j可以选择子数组中的一个单元（大小为int）。 / p>

最后一点：我曾口头谈论过“多维数组”，但严格来说，正如这里的许多常客所指出的那样，C没有多维数组。它只有一维数组，正如我们在此处看到的那样，我们实际上认为的二维数组是一维数组，其元素恰好是其他一维数组。 （如果C具有真正的多维数组，则下标可能看起来像a[i,j]而不是a[i][j]。）

---

附录：尽管您提到了指针算术，而我也提到了指针算术，但重要的是要认识到 a的定义中没有指针。仅当我们尝试“获取” a的值或解释a[i]与*(a + i)等效时，指针才会出现。

对于确实包含指针的数据结构，我们可以对比代码描述的情况

int *a2[NUM_ROWS];
for(i = 0; i < NUM_ROWS; i++)
    a2[i] = malloc(NUM_COLS * sizeof(int));

这为我们提供了非常不同的内存布局：

    +-----+
a2: |     |     +--------+--------+--------+--------+
    |  *------->|        |        |        |        |
    |     |     +--------+--------+--------+--------+
    +-----+
    |     |     +--------+--------+--------+--------+
    |  *------->|        |        |        |        |
    |     |     +--------+--------+--------+--------+
    +-----+
    |     |     +--------+--------+--------+--------+
    |  *------->|        |        |        |        |
    |     |     +--------+--------+--------+--------+
    +-----+

这就是通常所说的“参差不齐”或“参差不齐”的数组，因为在这种情况下，所有行的长度都不必相同。但是，几乎可以魔术地使用“ a2[i][j]”表示法访问“参差不齐”数组中的单元格。为了获得完全的活力，我们可以使用

int **a3 = malloc(NUM_ROWS * sizeof(int *));
for(i = 0; i < NUM_ROWS; i++)
    a3[i] = malloc(NUM_COLS * sizeof(int));

导致此内存布局：

    +-----+
a3: |     |
    |  *  |
    |  |  |
    +--|--+
       |
       |
       V
    +-----+
    |     |     +--------+--------+--------+--------+
    |  *------->|        |        |        |        |
    |     |     +--------+--------+--------+--------+
    +-----+
    |     |     +--------+--------+--------+--------+
    |  *------->|        |        |        |        |
    |     |     +--------+--------+--------+--------+
    +-----+
    |     |     +--------+--------+--------+--------+
    |  *------->|        |        |        |        |
    |     |     +--------+--------+--------+--------+
    +-----+

a3[i][j]也可以在这里工作。

（当然，在构建诸如a2和a3之类的“动态数组”的真实代码中，我们必须检查以确保malloc不会返回{{1 }}。

Answer 2

另一种查看方式...

对于任何类型的T，我们创建一个数组为

T arr[N];

其中T可以是int，char，double，struct foo，无论是什么，都读为“ {{1}的N元素数组}”。也可以是另一种数组类型。因此，假设T不仅仅是int的 M元素数组，我们将其写为

T

这表示为“ int是int arr[N][M]; 的M元素数组的N元素数组”。这不是锯齿状的阵列-所有“行”的大小均相同。但这也不完全是二维数组-它是数组的数组。表达式arr具有数组类型（int）。

此视图还帮助我们找出指向数组类型的指针。除非它是arr[i]或一元int [M]运算符的操作数，或者是用于在声明中初始化字符数组的字符串文字，否则类型为“ N”的 expression sizeof”（&）的-element数组将被转换（“衰减”）为“指向T的指针（T [N]）类型的表达式。同样，如果将T替换为数组类型T *，则表达式为“ T的M元素数组的N元素数组”（int [M] ），它会“衰减”以键入“ int的M元素数组的指针”（int [N][M]）。