在 C 语言中，为什么数组的地址等于它的值？

Question

在下面的代码中，指针值和指针地址与预期不同。

但数组值和地址则不然！

怎么会这样呢？

输出

my_array = 0022FF00
&my_array = 0022FF00
pointer_to_array = 0022FF00
&pointer_to_array = 0022FEFC

#include <stdio.h>

int main()
{
  char my_array[100] = "some cool string";
  printf("my_array = %p\n", my_array);
  printf("&my_array = %p\n", &my_array);

  char *pointer_to_array = my_array;
  printf("pointer_to_array = %p\n", pointer_to_array);
  printf("&pointer_to_array = %p\n", &pointer_to_array);

  printf("Press ENTER to continue...\n");
  getchar();
  return 0;
}

Answer 1

数组的名称通常计算为数组第一个元素的地址，因此 array 和 &array 具有相同的值（但类型不同，因此 如果数组长度超过 1 个元素，>array+1 和 &array+1 将不相等。

有两个例外：当数组名称是 sizeof 或一元 & (address-of) 的操作数时，名称指的是数组对象本身。因此，sizeof array 为您提供整个数组的大小（以字节为单位），而不是指针的大小。

对于定义为 T array[size] 的数组，其类型为 T *。当/如果你增加它，你就会到达数组中的下一个元素。

&array 求值为相同的地址，但给定相同的定义，它创建一个类型为 T(*)[size] 的指针——即，它是一个指针到一个数组，而不是单个元素。如果增加此指针，它将添加整个数组的大小，而不是单个元素的大小。例如，对于这样的代码：

char array[16];
printf("%p\t%p", (void*)&array, (void*)(&array+1));

我们可以预期第二个指针比第一个指针大 16（因为它是一个 16 个字符的数组）。由于 %p 通常将指针转换为十六进制，因此它可能看起来像：

0x12341000    0x12341010

Answer 2

这是因为数组名称 (my_array) 与指向数组的指针不同。它是数组地址的别名，其地址被定义为数组本身的地址。

然而，该指针是堆栈上的普通 C 变量。因此，您可以获取它的地址并获得与它内部保存的地址不同的值。

我在此处写了有关此主题的文章 - 请看看吧。

Answer 3

在 C 中，当您在表达式中使用数组名称（包括将其传递给函数）时，除非它是地址 (&) 运算符或 的操作数sizeof 运算符，它衰减为指向其第一个元素的指针。

也就是说，在大多数情况下，array 在类型和值上都相当于 &array[0]。

在您的示例中，my_array 的类型为 char[100]，当您将其传递给 printf 时，该类型会衰减为 char*。

&my_array 的类型为 char (*)[100]（指向 100 个 char 数组的指针）。由于它是 & 的操作数，因此这是 my_array 不会立即衰减为指向其第一个元素的指针的情况之一。

指向数组的指针与指向数组第一个元素的指针具有相同的地址值，因为数组对象只是其元素的连续序列，但指向数组的指针与指向数组元素的指针具有不同的类型那个数组。当您对两种类型的指针进行指针算术时，这一点很重要。

pointer_to_array 具有类型 char * - 初始化为指向数组的第一个元素，因为这是 my_array 在初始化表达式中衰减的内容 - 并且&pointer_to_array 的类型为 char **（指向 char 指针的指针）。

其中：my_array（衰减为char*后）、&my_array和pointer_to_array都直接指向任一数组或数组的第一个元素，因此具有相同的地址值。

Answer 4

当您查看数组的内存布局时，可以很容易地理解 my_array 和 &my_array 产生相同地址的原因。

假设您有一个包含 10 个字符的数组（而不是代码中的 100 个字符）。

char my_array[10];

my_array 的内存看起来像这样：

+---+---+---+---+---+---+---+---+---+---+
|   |   |   |   |   |   |   |   |   |   |
+---+---+---+---+---+---+---+---+---+---+
^
|
Address of my_array.

在 C/C++ 中，数组衰减为指向表达式中第一个元素的指针，例如

printf("my_array = %p\n", my_array);

如果您检查数组的第一个元素所在的位置，您会发现它地址与数组的地址相同：

my_array[0]
|
v
+---+---+---+---+---+---+---+---+---+---+
|   |   |   |   |   |   |   |   |   |   |
+---+---+---+---+---+---+---+---+---+---+
^
|
Address of my_array[0].

Answer 5

在 B 编程语言（C 的前身）中，
指针和整数可以自由互换。该系统将表现为
尽管所有的内存都是一个巨大的数组。每个变量名都有一个全局变量
或堆栈相对地址
与之相关的是，对于每个变量名，编译器必须跟踪的唯一事情是它是全局变量还是局部变量，以及它相对于第一个全局变量或局部变量的地址。

给定像 i; 这样的全局声明[不需要指定类型，因为一切都是整数/指针]将由
编译器为：address_of_i = next_global++; memory[address_of_i] = 0; 并且像 i++ 这样的语句将被处理为：memory[address_of_i] = memory[address_of_i]+1;。

像 arr[10]; 这样的声明将被处理为 address_of_arr = next_global;内存[next_global] = next_global; next_global += 10;。请注意，一旦处理该声明，编译器就会立即忘记 arr 是一个数组。像 arr[i]=6; 这样的语句将被处理为 memory[memory[address_of_a] + memory[address_of_i]] = 6;。编译器不会关心 arr 是否表示数组而 i 是否表示整数，反之亦然。事实上，它不会关心它们是否都是数组或都是整数；它会非常高兴地生成所描述的代码，而不考虑生成的行为是否可能有用。

C 编程语言的目标之一是与 B 很大程度上兼容。在 B 中，数组的名称[在 B 的术语中称为“向量”]标识了一个包含指针的变量，该指针最初被分配为指向到给定大小的分配的第一个元素，因此如果该名称出现在函数的参数列表中，则该函数将接收指向该向量的指针。尽管 C 添加了“真正的”数组类型，其名称与分配的地址严格相关，而不是最初指向分配的指针变量，但将数组分解为指针使得声明 C 类型数组的代码表现相同B 代码声明了一个向量，然后从未修改保存其地址的变量。

Answer 6

实际上 &myarray 和 myarray 都是基地址。

如果你想看到差异而不是使用

printf("my_array = %p\n", my_array);
printf("my_array = %p\n", &my_array);

use

printf("my_array = %s\n", my_array);
printf("my_array = %p\n", my_array);