数组名是指针吗？

Question

数组的名称是 C 中的指针吗？ 如果不是，数组名和指针变量有什么区别？

Answer 1

数组是数组，指针是指针，但在大多数情况下，数组名称​​转换为指针。经常使用的一个术语是它们衰减为指针。

这是一个数组：

int a[7];

a 包含七个整数的空间，您可以通过赋值将值放入其中一个，如下所示：

a[3] = 9;

这是一个指针：

int *p;

p 不包含任何整数空格，但它可以指向整数空格。例如，我们可以将其设置为指向数组a中的一个位置，比如第一个：

p = &a[0];

令人困惑的是，你也可以这样写：

p = a;

这不会将数组a 的内容复制到指针p 中（无论这意味着什么）。相反，数组名称a 被转换为指向其第一个元素的指针。所以这个任务和前一个任务是一样的。

现在您可以像使用数组一样使用p：

p[3] = 17;

之所以有效，是因为 C 中的数组解引用运算符 [ ] 是根据指针定义的。 x[y] 的意思是：从指针x 开始，在指针指向的内容之后向前步进y 元素，然后取其中的任何内容。使用指针算术语法，x[y]也可以写成*(x+y)。

要让这个函数与普通数组一起工作，例如我们的a，必须首先将a[3] 中的名称a 转换为指针（指向a 中的第一个元素）。然后我们向前迈进 3 个元素，并取走那里的任何东西。换句话说：取数组中位置 3 的元素。 （这是数组中的第四个元素，因为第一个元素编号为 0。）

因此，总而言之，C 程序中的数组名（在大多数情况下）被转换为指针。一个例外是当我们在数组上使用sizeof 运算符时。如果a 在此上下文中被转换为指针，sizeof a 将给出指针的大小而不是实际数组的大小，这将是相当无用的，所以在这种情况下a 表示数组本身。

Answer 2

当数组用作值时，其名称代表第一个元素的地址。
当数组不用作值时，它的名称代表整个数组。

int arr[7];

/* arr used as value */
foo(arr);
int x = *(arr + 1); /* same as arr[1] */

/* arr not used as value */
size_t bytes = sizeof arr;
void *q = &arr; /* void pointers are compatible with pointers to any object */

Answer 3

如果数组类型的表达式（例如数组名​​称）出现在更大的表达式中，并且它不是 & 或 sizeof 运算符的操作数，则数组表达式的类型从“T的N元素数组”到“指向T的指针”，表达式的值是数组中第一个元素的地址。

简而言之，数组名不是指针，但在大多数情况下，它被视为就像它是一个指针。

编辑

回答评论中的问题：

如果我使用 sizeof，我是否只计算数组元素的大小？那么数组“head”也占用空间，包含长度和指针信息（这意味着它比普通指针占用更多空间）？

创建数组时，唯一分配的空间是元素本身的空间；没有为单独的指针或任何元数据实现存储。给定

char a[10];

你在记忆中得到的是

   +---+
a: |   | a[0]
   +---+ 
   |   | a[1]
   +---+
   |   | a[2]
   +---+
    ...
   +---+
   |   | a[9]
   +---+

表达式 a 指的是整个数组，但没有object a 与数组元素本身分开。因此，sizeof a 为您提供了整个数组的大小（以字节为单位）。表达式&a 为您提供数组的地址，与第一个元素的地址相同。 &a 和 &a[0] 之间的区别在于结果的类型¹ - 第一种情况下的char (*)[10] 和第二种情况下的char *。

当你想要访问单个元素时，事情变得奇怪了——表达式a[i]被定义为*(a + i)的结果——给定地址值a，偏移量i元素（不是字节) 从该地址并取消引用结果。

问题在于a 不是指针或地址——它是整个数组对象。因此，C 中的规则是，只要编译器看到数组类型的表达式（例如 a，其类型为 char [10]）并且该表达式不是 sizeof 的操作数或一元 & 运算符，该表达式的类型被转换（“decays”）为指针类型（char *），表达式的值是数组第一个元素的地址。因此，表达式 a 与表达式&a[0] 具有相同的类型和值（并且通过扩展，表达式*a 具有与表达式a[0] 相同的类型和值）。

C 派生自一种称为 B 的早期语言，在 B 中，a是一个独立于数组元素 a[0]、a[1] 等的指针对象。Ritchie 想要保留 B 的数组语义，但他不想弄乱存储单独的指针对象。所以他摆脱了它。相反，编译器将在翻译过程中根据需要将数组表达式转换为指针表达式。

请记住，我说过数组不存储有关其大小的任何元数据。一旦该数组表达式“衰减”为指针，您所拥有的只是一个指向单个元素的指针。该元素可能是一系列元素中的第一个，也可能是单个对象。没有办法根据指针本身知道。

当您将数组表达式传递给函数时，函数接收到的所有内容都是指向第一个元素的指针 - 它不知道数组有多大（这就是为什么 gets 函数如此威胁并最终从图书馆中删除）。要让函数知道数组有多少元素，您必须使用标记值（例如 C 字符串中的 0 终止符），或者必须将元素数量作为单独的参数传递。

---

1. 这*可能*影响地址值的解释方式 - 取决于机器。

Answer 4

这样声明的数组

int a[10];

为 10 ints 分配内存。你不能修改a，但是你可以用a做指针运算。

这样的指针只为指针p分配内存：

int *p;

它不分配任何ints。你可以修改它：

p = a;

并尽可能使用数组下标：

p[2] = 5;
a[2] = 5;    // same
*(p+2) = 5;  // same effect
*(a+2) = 5;  // same effect

Answer 5

数组名本身会产生一个内存位置，因此您可以将数组名视为指针：

int a[7];

a[0] = 1976;
a[1] = 1984;

printf("memory location of a: %p", a);

printf("value at memory location %p is %d", a, *a);

你可以对指针做其他漂亮的事情（例如添加/减去偏移量），你也可以对数组做：

printf("value at memory location %p is %d", a + 1, *(a + 1));

语言方面，如果 C 没有将数组公开为 某种“指针”（迂腐地它只是一个内存位置。它不能指向内存中的任意位置，也不能指向由程序员控制）。我们总是需要这样编码：

printf("value at memory location %p is %d", &a[1], a[1]);

Answer 6

我认为这个例子说明了这个问题：

#include <stdio.h>
int main()
{
        int a[3] = {9, 10, 11};
        int **b = &a;

        printf("a == &a: %d\n", a == b);
        return 0;
}

它在 gcc 4.9.2 中编译良好（带有 2 个警告），并打印以下内容：

a == &a: 1

哎呀 :-)

因此，结论是否定的，数组不是指针，它不是作为指针存储在内存中（甚至不是只读的），即使看起来是这样，因为您可以通过以下方式获取它的地址运营商。但是 - 哎呀 - 该运算符不起作用 :-))，无论哪种方式，您都已被警告：

p.c: In function ‘main’:
pp.c:6:12: warning: initialization from incompatible pointer type
  int **b = &a;
            ^
p.c:8:28: warning: comparison of distinct pointer types lacks a cast
  printf("a == &a: %d\n", a == b);

C++ 在编译时拒绝任何此类尝试。

编辑：

这就是我想要展示的：

#include <stdio.h>
int main()
{
    int a[3] = {9, 10, 11};
    void *c = a;

    void *b = &a;
    void *d = &c;

    printf("a == &a: %d\n", a == b);
    printf("c == &c: %d\n", c == d);
    return 0;
}

即使c和a“指向”同一个内存，你可以得到c指针的地址，但是你不能得到a指针的地址。

Answer 7

以下示例提供了数组名称和指针之间的具体区别。假设您想用给定的最大维度表示一维线，您可以使用数组或指针来完成：

typedef struct {
   int length;
   int line_as_array[1000];
   int* line_as_pointer;
} Line;

现在让我们看看以下代码的行为：

void do_something_with_line(Line line) {
   line.line_as_pointer[0] = 0;
   line.line_as_array[0] = 0;
}

void main() {
   Line my_line;
   my_line.length = 20;
   my_line.line_as_pointer = (int*) calloc(my_line.length, sizeof(int));

   my_line.line_as_pointer[0] = 10;
   my_line.line_as_array[0] = 10;

   do_something_with_line(my_line);

   printf("%d %d\n", my_line.line_as_pointer[0], my_line.line_as_array[0]);
};

这段代码将输出：

0 10

这是因为在对do_something_with_line的函数调用中，对象被复制了，所以：

1. 指针line_as_pointer 仍然包含它指向的相同地址
2. 数组line_as_array 被复制到一个新地址，该地址不超出函数的范围

因此，当您将数组直接输入到函数时，虽然数组不是由值给出的，但当您将它们封装在结构中时，它们是由值给出（即复制），这在这里概述了与使用指针的实现相比在行为上的主要区别。

Answer 8

数组名的行为类似于指针，指向数组的第一个元素。示例：

int a[]={1,2,3};
printf("%p\n",a);     //result is similar to 0x7fff6fe40bc0
printf("%p\n",&a[0]); //result is similar to 0x7fff6fe40bc0

对于一台机器，两个打印语句都会给出完全相同的输出。在我的系统中它给出了：

0x7fff6fe40bc0

Answer 9

数组名是数组第一个元素的地址。所以是的，数组名是一个常量指针。