为什么这会产生分段错误？

Question

#include<stdio.h>
void foo(int **arr) {
    arr[1][1]++;
}

main() {
    int arr[20][20];
    printf("%d\n",arr[1][1]);
    foo((int**)arr);
    printf("%d\n",arr[1][1]);
}

Answer 1

假设您声明：
int arr[10][20];
arr 是什么类型？
您可能认为它是 int **，但这是不正确的。

当它衰减时（就像当你将它传递给函数时），它实际上是 int (*)[20] 类型；
数组衰减仅适用一次。

详细信息请参见此处

---

现在考虑以下内容，

#include<stdio.h>
#include<stdlib.h>
void foo(int arr[][20]) {
  arr[1][1]++;
}
main() {
  int (*arr)[20];
  arr = malloc(sizeof(int (*)[]) * 2); //2 rows & malloc will do implicit cast.

  printf("%d\n",arr[1][1]);
  foo(arr);
  printf("%d\n",arr[1][1]);
}

输出：

$ gcc fdsf.c && ./a.out
0
1

---

arr 和 arr+1 指向 20 个整数的数组。

arr + 0 -->            int   ...    int (20整数，连续）
          [0][0]   [0][1]
arr + 1 -->            int   ...    int (20整数，连续）
          [1][0]   [1][1]

Answer 2

int[2][2] 在内存中的样子如下：

int[2] int[2]

也就是说，一个数组后面紧跟着另一个数组。

int[2] 在内存中的样子如下：

int int

也就是说，一个 int 后面紧跟着另一个 int。

因此，这也是 int[2][2] 在内存中的样子：

int int int int
     ^       ^
     |       |___ this is arr[1][1]
     |
     |____ this is p[1], assuming sizeof(int*) == sizeof(int)

如果将 arr 转换为 int**，我我将调用结果p。然后它指向同一个内存。当您执行 p[1][1] 时，您不会得到 arr[1][1]。相反，程序执行的操作是读取 p[1] 处的值，将其调整为 int 的大小，然后取消引用。如果第二个 int 包含值“21”，那么您刚刚尝试取消引用指针“25”（如果 int 是 4 个字节）。那是不对的。

数组与指针不同，二维数组当然也与指向指针的指针不同。

Answer 3

因为 foo 期望一个指向 int 的指针，而您正在向它传递一个指向 20 int 数组的指针。转换它不会改变它不是正确类型的事实。

Answer 4

如果你像这样改变它，你会得到预期的结果：

#include<stdio.h>
void foo(int arr[][20]) {
    arr[1][1]++;
}

int
main() {
    int arr[20][20];
    arr[1][1] = 1;
    printf("%d\n",arr[1][1]);
    foo(arr);
    printf("%d\n",arr[1][1]);
}

Answer 5

foo 需要知道数组大小（嗯，至少是第二个数组维度，第一个不需要），否则它无法为 [1][ 执行必要的指针算术1]。

Answer 6

问题是 2d 数组的 int arr[20][20] 意味着该数组存储为 1d 数组，并且行是一个接一个地存储的。当您对 int **arr 进行索引时，您实际上从数组的第一行获取第二个元素，然后取消引用它并在那里获取第一个元素。