a, &a, *a, a[0], &a[0] 和 &a[0][0] 是相同的指针吗？

Question

我有以下 C 程序：

#include <stdio.h>

int main(){
    int a[2][2] = {1, 2, 3, 4};
    printf("a:%p, &a:%p, *a:%p \n", a, &a, *a);
    printf("a[0]:%p, &a[0]:%p \n", a[0], &a[0]);
    printf("&a[0][0]:%p \n", &a[0][0]);
    return 0;
}

它给出以下输出：

a:0028FEAC, &a:0028FEAC, *a:0028FEAC
a[0]:0028FEAC, &a[0]:0028FEAC
&a[0][0]:0028FEAC

我无法理解为什么&a、a、*a - 都相同。 a[0]、&a[0] 和 &a[0][0] 也是如此。

编辑：

多亏了答案，我明白了这些值相等的原因。 Kernighan & Ritchie 书中的这句话原来是我问题的关键：

 the name of an array is a synonym for the location of the initial element.

所以，通过这个，我们得到

a = &a[0]，和

a[0] = &a[0][0]（将a 视为数组数组）

直观地说，现在输出背后的原因很清楚了。但是，考虑到指针是如何在 C 中实现的，我无法理解 a 和 &a 是如何相等的。我假设内存中有一个变量a 指向数组（并且这个数组内存块的起始地址将是这个变量a 的值）。

但是，当我们执行&a 时，这是否意味着获取存储变量a 的内存位置的地址？那为什么这些值相等呢？

Answer 1

它们不是 相同的 指针。它们是指向同一个内存位置的不同类型的指针。相同的值（某种），不同的类型。

C 中的二维数组只不过是数组的数组。

对象a 的类型为int[2][2]，或int 的2 元素数组的2 元素数组。

在大多数但不是所有的上下文中，任何数组类型的表达式都会隐式转换为（“衰减”为）指向数组对象第一个元素的指针。所以 表达式 a，除非它是一元 & 或 sizeof 的操作数，其类型为 int(*)[2]，并且等价于 &a[0]（或 &(a[0])，如果更清楚的话）。它成为指向二维数组第 0 行的指针。重要的是要记住这是一个指针值（或等效的一个地址），而不是一个指针对象；这里没有指针对象，除非你明确地创建一个。

所以看看你问的几个表达方式：

• &a是整个数组对象的地址；它是int(*)[2][2] 类型的指针表达式。
• a 是数组的名称。如上所述，它“衰减”为指向数组对象第一个元素（行）的指针。这是一个int(*)[2] 类型的指针表达式。
• *a 取消引用指针表达式a。因为a（衰减后）是一个指向2个ints数组的指针，所以*a是2个ints数组。由于这是一个数组类型，它（在大多数但不是所有上下文中）衰减为指向数组对象第一个元素的指针。所以它的类型是int*。 *a 等价于 &a[0][0]。
• &a[0] 是数组对象的第一（0）行的地址。它的类型为int(*)[2]。 a[0] 是一个数组对象；它不会衰减为指针，因为它是一元 & 的直接操作数。
• &a[0][0] 是数组对象第 0 行第 0 元素的地址。它的类型为int*。

所有这些指针表达式都指向内存中的相同位置。该位置是数组对象a 的开头；它也是数组对象a[0] 和int 对象a[0][0] 的开始。

打印指针值的正确方法是使用"%p"格式和将指针值转换为void*：

printf("&a = %p\n", (void*)&a);
printf("a  = %p\n", (void*)a);
printf("*a = %p\n", (void*)*a);
/* and so forth */

到void* 的这种转换会产生一个“原始”地址，它只指定内存中的一个位置，而不是该位置的对象类型。因此，如果您有多个不同类型的指针指向从同一内存位置开始的对象，则将它们全部转换为 void* 会产生相同的值。

（我已经忽略了[] 索引运算符的内部工作原理。表达式x[y] 在定义上等同于*(x+y)，其中x 是一个指针（可能是隐式转换的结果）一个数组）和y 是一个整数。反之亦然，但这很难看；arr[0] 和0[arr] 是等价的，但只有在您编写故意混淆的代码时才有用。如果我们考虑到这种等价性，它用一段左右的时间来描述a[0][0]的意思，这个答案可能已经太长了。）

为了完整起见，数组类型的表达式不隐式转换为指向数组第一个元素的指针的三个上下文是：

• 当它是一元&的操作数时，所以&arr产生整个数组对象的地址；
• 当它是sizeof 的操作数时，所以sizeof arr 产生数组对象的字节大小，而不是指针的大小；和
• 当它是用于初始化数组（子）对象的初始化程序中的字符串文字时，char s[6] = "hello"; 将数组值复制到s，而不是用指针值无意义地初始化数组对象。最后一个例外不适用于您询问的代码。

（2011 ISO C 标准的N1570 草案错误地指出_Alignof 是第四个例外；这是不正确的，因为_Alignof 只能应用于带括号的类型名称，而不是表达式。错误在最终的 C11 标准中得到纠正。）

推荐阅读：comp.lang.c FAQ第6节。

Answer 2

因为所有表达式都指向数组的开头：

a = {{a00},{a01},{a10},{a11}}

a指向数组，只是因为是数组，所以a == &a[0]

而&a[0][0] 位于二维数组的第一个单元格处。

Answer 3

 +------------------------------+
 | a[0][0]   <--   a[0] <--   a | // <--&a, a,*a, &a[0],&a[0][0] 
 |_a[0][1]_                     |
 | a[1][0]   <--   a[1]         |
 | a[1][1]                      |
 +------------------------------+

Answer 4

它打印出相同的值，因为它们都指向同一个位置。

话虽如此，

&a[i][i] 是 int * 类型，它是一个指向整数的指针。

a 和 &a[0] 的类型为 int(*)[2]，表示指向 2 整数数组的指针。

&a 的类型为int(*)[2][2]，它表示指向2-D array 的指针或指向两个元素数组的指针，其中每个元素都是2 个整数的数组。

因此，如果您开始对它们进行指针运算，它们都是不同的类型并且行为不同。

(&a[0][1] + 1) 指向二维数组中的下一个整数元素，即a[0][1]

&a[0] + 1 指向下一个整数数组，即a[1][0]

&a + 1 指向下一个二维数组，在这种情况下不存在，但如果存在则为 a[2][0]。

Answer 5

您知道a 是数组第一个元素的地址，根据C 标准，a[X] 等于*(a + X)。

所以：

&a[0] == a 因为&a[0] 与&(*(a + 0)) = &(*a) = a 相同。

&a[0][0] == a 因为&a[0][0] 与&(*(*(a + 0) + 0))) 相同 = &(*a) = a

Answer 6

C 中的二维数组被视为一维数组，其元素是一维数组（行）。
例如，T 的 4x3 数组（其中“T”是某种数据类型）可能 由：T a[4][3] 声明，并由以下描述 方案：

                       +-----+-----+-----+
  a ==     a[0]   ---> | a00 | a01 | a02 |
                       +-----+-----+-----+
                       +-----+-----+-----+
           a[1]   ---> | a10 | a11 | a12 |
                       +-----+-----+-----+
                       +-----+-----+-----+
           a[2]   ---> | a20 | a21 | a22 |
                       +-----+-----+-----+
                       +-----+-----+-----+
           a[3]   ---> | a30 | a31 | a32 |
                       +-----+-----+-----+

数组元素也被逐行存储在内存中。
在T 前面加上[3] 到a 我们有一个3 类型为T 的元素数组。但是，名称a[4] 本身是一个数组，表示存在4 元素，每个元素都是3 元素的数组。因此，我们有一个 4 数组，每个数组都有 3 元素。
现在很明显 a 指向 a[4] 的第一个元素 (a[0])。另一方面，&a[0] 将给出a[4] 的第一个元素（a[0]）的地址，&a[0][0] 将给出0th 行的地址（a00 | a01 | a02) 数组a[4][3]。&a 将给出二维数组的地址a[3][4]。*a 衰减为指向a[0][0] 的指针。
注意a不是指向a[0][0]的指针；相反，它是指向a[0] 的指针。
因此

• G1：a 和 &a[0] 是等效的。
• G2：*a、a[0]和&a[0][0]是等价的。
• G3：&a（给出二维数组a[3][4]的地址）。
  但是组 G1、G2 和 G3 并不相同，尽管它们给出了相同的结果（我在上面解释过为什么它给出相同的结果）。

Answer 7

这也意味着在 C 数组中没有开销。在其他一些语言中，数组的结构是

&a     -->  overhead
            more overhead
&a[0]  -->  element 0
            element 1
            element 2
            ...

和&a != &a[0]

Answer 8

直观地说，现在输出背后的原因很清楚了。但是，考虑到指针是如何在 C 中实现的，我无法理解 a 和 &a 是如何相等的。我假设内存中有一个变量 a 指向数组（这个数组内存块的起始地址就是这个变量 a 的值）。

嗯，不。在内存中的任何地方都没有存储地址之类的东西。只为原始数据分配了内存，仅此而已。发生的情况是，当您使用裸 a 时，它立即衰减 成为指向第一个元素的指针，给人的印象是 a 的“值”是地址，但唯一的a 的值是原始数组存储。

其实a和&a是不同的，只是类型不同，值不同。让我们通过使用一维数组来澄清这一点，让它变得更容易一些：

bool foo(int (*a)[2]) {    //a function expecting a pointer to an array of two elements
    return (*a)[0] == (*a)[1];    //a pointer to an array needs to be dereferenced to access its elements
}
bool bar(int (*a)[3]);    //a function expecting a pointer to an array of three elements
bool baz(int *a) {    //a function expecting a pointer to an integer, which is typically used to access arrays.
    return a[0] == a[1];    //this uses pointer arithmetic to access the elements
}

int z[2];
assert((size_t)z == (size_t)&z);    //the value of both is the address of the first element.
foo(&z);     //This works, we pass a pointer to an array of two elements.
//bar(&z);   //Error, bar expects a pointer to an array of three elements.
//baz(&z);   //Error, baz expects a pointer to an int

//foo(z);    //Error, foo expects a pointer to an array
//bar(z);    //Error, bar expects a pointer to an array
baz(z);      //Ok, the name of an array easily decays into a pointer to its first element.

如您所见，a 和 &a 的行为非常不同，尽管它们共享相同的值。