“地址” (&) 一个被gcc忽略的数组/地址？

Question

我是编程入门课程的助教，有些学生犯了这种类型的错误：

char name[20];
scanf("%s",&name);

这并不奇怪，因为他们正在学习......令人惊讶的是，除了 gcc 警告之外，代码还可以工作（至少这部分） 。我一直在试图理解并编写了以下代码：

void foo(int *v1, int *v2) {
  if (v1 == v2)
    printf("Both pointers are the same\n");
  else
    printf("They are not the same\n");
}

int main() {
  int test[50];
  foo(&test, test);
  if (&test == test)
    printf("Both pointers are the same\n");
  else
    printf("They are not the same\n");
}

编译和执行：

$ gcc test.c -g
test.c: In function ‘main’:
test.c:12: warning: passing argument 1 of ‘foo’ from incompatible pointer type
test.c:13: warning: comparison of distinct pointer types lacks a cast
$ ./a.out 
Both pointers are the same
Both pointers are the same

任何人都可以解释为什么它们没有不同吗？

我怀疑这是因为我无法获取数组的地址（因为我无法获得 & &x），但在这种情况下，代码不应编译。

编辑：我知道数组本身与第一个元素的地址相同，但我认为这与这个问题无关。例如：

int main() {
  int a[50];
  int * p = a;
  printf("%d %d %d\n", p == a, p == &a[0], &p[0] == a);
  printf("%d %d %d\n", p == &a, &p == a, &p == &a);
}

prints:

$ ./a.out 
1 1 1
1 0 0

我不明白为什么第二行以 1 开头。

Answer 1

在您的示例中，数组 test 是一个由 50 个 int 组成的块。所以它看起来像这样：

| int | int | ... | int |

当您将一元 & 运算符应用于数组时，您将获得数组的地址。就像你将它应用到其他任何事情上一样，真的。因此，&test 是一个指向 50 个 ints 块的指针：

(&test) -----------> | int | int | ... | int |

指向 50 个 ints 数组的指针的类型为 int (*)[ 50] - 这是 &test 的类型。

当您在任何不是 sizeof 或一元-& 运算符的操作数的地方使用名称 test 时，就会对它进行求值指向其第一个元素的指针。因此，您传递给 foo() 的 test 的计算结果为指向 test[0] 元素的指针：

(test) -----------------\
                        v
(&test) -----------> | int | int | ... | int |

您可以看到这两者都是指向相同的地址 - 尽管 &test 指向整个数组，而 test 指向数组的第一个元素（仅显示在不同的数组中）这些值所具有的类型）。

Answer 2

事实上，它们是不同的，至少不是同一类型。

但在C语言中，数组的地址与数组的地址相同。
数组中的第一个元素，这就是为什么“它们没有不同”，基本上，它们指向同一件事。

Answer 3

如果您定义像 name 这样的数组，

char name[20];

则可隐式转换为 char*，但 &name 的类型为 char (*) [20]（指向 20 个字符的数组的指针）。地址是相同的。

检查(&name + 1)的地址。它的 &name 形式与 sizeof(char [20]) 不同。

Answer 4

在大多数情况下，数组的名称​​计算为其初始元素的地址。两个例外是当它是 sizeof 或一元 & 的操作数时。

一元 & 给出其参数的地址。数组的地址与其初始元素的地址相同，因此 (void*)&array == (void*)array 始终为 true。

array 当转换为指向其初始元素的指针时，其类型为 T *。 &array 的类型为 T (*)[n]，其中 n 是数组中元素的数量。因此，

int* p = array;        // Works; p is a pointer to array[0]
int* q = &array;       // Doesn't work; &array has type int (*)[10]
int (*r)[10] = &array; // Works; r is a pointer to array

Answer 5

我相信这是 gcc 的优化。想一想。

• &test 指向 test 的地址
• test 指向 test 或 & 的第一个元素;test[0]
• [0] 与 * 相同（大部分）

因此根据此 &test 可能与test不同，但 gcc 对此进行了优化，因为此时没有额外的间接级别。