为什么我的程序在使用二维数组参数的函数时会抛出“不兼容的整数到指针转换”错误？

Question

我收到以下错误：

warning: incompatible integer to pointer conversion passing 'int' to parameter of type 'int (*)[50]'

我正在尝试传递一个函数，该函数将遍历 2D 数组中的每个单元格并计算可被 6 整除但不能被 5 整除的单元格中的值。出于某种原因，我收到上述错误，但不知道为什么& 在网上找不到与该错误相关的任何内容。
我认为 C 在涉及 2D 数组时很奇怪，我认为它与此有关，但任何建议将不胜感激。

我的代码如下：

#include<stdio.h>

int arrayCounter(int arr[40][50]) {
    int counter = 0; 
    for (int i = 0; i < 40 ; i ++) {
        for (int j = 0 ; j < 50 ; j ++) {
            if(arr[i][j] % 6  == 0 && arr[i][j] % 5 !=0 ) {
                counter ++;
            }
    
        }
    }
    return counter;
}

int main() {
    int array[40][50];
    for (int i = 0; i < 40; i++) {
        for(int j = 0; j < 50; j++) {
            array[i][j] = (i+1) * (j+1);
            printf("%d", arrayCounter(array[i][j]));
        }
    }
    return 0;
}

除了在 array[i][j] 前面添加 '&' 来看看是否可以解决错误之外，我没有尝试太多，但没有成功。我不是 C 的初学者，但在多年不使用该语言后又回到了 C。

我最大的困惑之一是为什么程序声明我的参数是第一个数组的指针，而它在函数中明确定义了。

Answer 1

我知道 C 对于 2D 数组来说很奇怪

嗯，这是一个意见。

C

是为了帮助编写 Unix（操作系统）而编写的。

C

中的数组与内存和机器非常接近，就像在汇编器中一样：数组是一个地址和偏移量。其他人可以说它很聪明，而且非常非常快。

并且在

C

中不存在

2D

数组或多维数组（如 FORTRAN 中那样）。只有一个数组。但数组可以是数组的数组的数组等等......

当你声明时

    int array[40][50];

您正在将名称

array

声明为类型

int

的变量。

[]

的存在将其变成

int

数组。所以这里

array

在

int

数组中。事实上，因为我们有 2 组

[]

那么

array

是一个由 40 个数组组成的数组，其中 50 个

int

，而

array

是一个指针，即这 2,000 个

int

中第一个的地址。

并且

array[0]

是

int[50]

，

array[1]

是

int[50]

等等。

该命令的输出

    int array[40][50] = {0};
    printf("\
    size of `array` is %llu\n\
    size of 'int' here is %llu\n\
    size of array[0] is %llu\n",
    sizeof(array),sizeof(int),sizeof(array[0]));

在这里

    size of `array` is 8000
    size of 'int' here is 4
    size of array[0] is 200

你可以做数学计算。

数组从

array

开始，有 8,000 字节，最后一个元素是

array[39][49]

当您将其传递给函数时，该地址就是传递的内容。正如您所声明的，类型是

int[40][50]

和

C

具有指针算术：基于类型大小，因此

array[1][19]

是

int

并且可以像

array[1][19] = 42

一样简单地设置。从

array

地址开始（因此数组在某种意义上是一个指针），元素在内存中逐行放置。
因此，如果您有一个指向

int

的指针，您可以在此算术的基础上进行构建，并从

array[1][19]

获取值 as

    array[1][19] = 42;
    int* pI      = array[1] + 19;
    printf(
        "\
    array[1][19] = %d, *pI = %d [1]\n",
        array[1][19], *pI);
    pI  = (int*) (array[0] + sizeof(array[0])/sizeof(int) + 19);
    *pI = 17;
    printf(
        "\
    array[1][19] = %d, *pI = %d [2]\n",
        array[1][19], *pI);

并且

printf

来电显示

    size of `array` is 8000
    size of 'int' here is 4
    size of array[0] is 200
    array[1][19] = 42, *pI = 42 [1]
    array[1][19] = 17, *pI = 17 [2]

arrayCounter

仅返回一个数字

int arrayCounter(int arr[40][50])
{
    int counter = 0;
    for (int i = 0; i < 40; i++)
        for (int j = 0; j < 50; j++)
            if (arr[i][j] % 6 == 0)
                if (arr[i][j] % 5 != 0) counter++;
    return counter;
}

您可能会发现这样更容易阅读

完整示例

#include <stdio.h>
// Answer to #1
int arrayCounter(int arr[40][50])
{
    int counter = 0;
    for (int i = 0; i < 40; i++)
        for (int j = 0; j < 50; j++)
            if (arr[i][j] % 6 == 0)
                if (arr[i][j] % 5 != 0) counter++;
    return counter;
}

int main(void)
{
    int array[40][50] = {0};
    printf(
        "\
    size of `array` is %llu\n\
    size of 'int' here is %llu\n\
    size of array[0] is %llu\n",
        sizeof(array), sizeof(int), sizeof(array[0]));

    array[1][19] = 42;
    int* pI      = array[1] + 19;
    printf(
        "\
    array[1][19] = %d, *pI = %d [1]\n",
        array[1][19], *pI);
    pI  = (int*)(array[0] + sizeof(array[0]) / sizeof(int) +
                19);
    *pI = 17;
    printf(
        "\
    array[1][19] = %d, *pI = %d [2]\n",
        array[1][19], *pI);
    for (int i = 0; i < 40; i++)
        for (int j = 0; j < 50; j++)
            array[i][j] = (i + 1) * (j + 1);
    printf(
        "\n    cells that are divisible by 6 but not by 5: "
        "%d\n\n",
        arrayCounter(array));
}

输出

    size of `array` is 8000
    size of 'int' here is 4
    size of array[0] is 200
    array[1][19] = 42, *pI = 42 [1]
    array[1][19] = 17, *pI = 17 [2]

    cells that are divisible by 6 but not by 5: 533