在C中，arr，*arr，arr[0]和&arr[0][0]是否相同？

Question

我发现了一些类似的问题但不是这个..。

如果我拿到这个

 double B[3][3] = {{1.,0.,0.},{0.,1.,0.},{0.,0.,1.}};

然后：

B，*B，B[0]和&B[0][0]

是一样的吗？

例如，如果我创建此方法：

void suma(double A[][3], double *B, double *C);

int main(int argc, char **argv) {
     double A[3][3] = {{1.,2.,3.},{4.,5.,6.},{7.,8.,9.}};
     double B[3][3] = {{1.,0.,0.},{0.,1.,0.},{0.,0.,1.}};
     double C[3][3];

     suma(A, &B[0][0], C[0]);

     return 0;
}

void suma(double A[][3], double *B, double *C){
    for(int i = 0; i < 3; i++){
        for(int j = 0; j < 3; j++){
            *(C+i*3+j) = A[i][j] + *(B+i*3+j);
        }
    }
}

我可以用四种不同的方式调用这个函数，并且可以全部工作。

Answer 1

在C中，在大多数情况下，数组可能会衰减到指向数组的第一个元素的指针。所以：

• B类型为double[3][3]，衰变为double (*)[3] (指向3 doubles)
• *B数组的指针与B[0]相同，为double[3] (3倍数组)，衰变为double * (指向double).
• &B[0][0]的指针为double *.

类型)。

还有函数参数:在C中，数组不能是函数参数。因此，当用作函数参数的类型时，看起来像数组的不是数组，但实际上它是一个指针，忽略了第一个数组维度，例如：

void foo(double arr[3])
void foo(double arr[])

在现实中：

void foo(double* arr)

多维数组也是如此：

void foo(double arr[2][3])
void foo(double arr[][3])

在现实中：

void foo(double (*arr)[3])

考虑到以上这些，让我们来看看，您的示例

void foo(double p[][3]);
// is actually:
void foo(double (*p)[3]);

foo(A);

A衰变为double (*)[3]，这是预期的参数类型。所以一切都很好。

void foo(double* p);

foo(&B[0][0])

这里也没有问题，直接传递一个指向第一个双元素的指针。

void foo(double* p)

foo(C[0]);

C[0]类型为double[3]，衰变为double*，这是预期的参数类型。再来一次，好吧。

Answer 2

不，B，*B，B[0]和&B[0][0]是不一样的。

它们的类型不同：

• B：数组3，double
• *B：数组3，double
• B[0]：数组3，double
• &B[0][0]：指针指向双

3

当允许它们衰减到指针(第四项已经是指针)时，类型仍然不同：

• B：指针指向数组3 double
• *B：指针指向double
• B[0]：指针指向double
• &B[0][0]：指针指向双重

由于指向数组的指针等同于指向其第一个元素的指针，所以这四个表达式具有相同的值。

请注意，最后一个3具有相同的类型。这些都是完全等同的。第一个类型包含更多信息。它“知道”有3组双打。

这种类型的差异可以通过运行以下程序来显示：

#include <stdio.h>

double B[3][3] = {
    { 1., 0., 0. },
    { 0., 1., 0. },
    { 0., 0., 1. }
};

int main() {
    printf("%p: %zu\n", (void *) B, sizeof(*B));
    printf("%p: %zu\n", (void *) (*B), sizeof(*(*B)));
    printf("%p: %zu\n", (void *) (B[0]), sizeof(*(B[0])));
    printf("%p: %zu\n", (void *) (&B[0][0]), sizeof(*(&B[0][0])));
}

对我来说，产出：

0x404040: 24
0x404040: 8
0x404040: 8
0x404040: 8

您可以看到，第一项是不同的，因为它所指向的元素的大小是其他项的三倍。

Answer 3

编辑的：它们具有相同的值。

这个C代码：

#include <stdio.h>


int main()

{

    double arr[3][3] = {{1.,0.,0.},{0.,1.,0.},{0.,0.,1.}};


    printf("arr=%p \n", arr);
    printf("*arr=%p \n", *arr);
    printf("arr[0]=%p \n", arr[0]);
    printf("&arr[0][0]=%p \n", &arr[0][0]);

}

说：

arr=0x7ffc17d4dba0 
*arr=0x7ffc17d4dba0 
arr[0]=0x7ffc17d4dba0 
&arr[0][0]=0x7ffc17d4dba0