为什么 &a 在 main() 和其他方法中显示不同的值？

Question

void f(int a[]);

int main() {
    int a[11];
    printf("1.%x  ", &a);
    f(a);
}

void f(int a[]) {
    printf("2.%x    ", &a);
}

输出：

1.e0de4940  2.e0de4928  

但是当 & 被删除时输出将是相同的。 以及为什么不管数组大小相差12？

Answer 1

主要是printf的调用

int a[11];
printf("1.%x  ",&a);

需要使用转换说明符%p的地方输出数组a的地址。

在函数f内调用printf输出函数的局部变量（参数）a的地址

printf("2.%x    ", &a);

由于int *类型的数组和参数a占用的内存范围不同，所以它们的地址不同。

注意参数a获取main中声明的数组a的第一个元素的地址。所以参数a中存储的地址与main中数组a的地址相同。那是你可以写的

void f(int a[]);

int main() {
    int a[11];
    printf("1.%p  ", ( void * )&a);
    f(a);
}

void f(int a[]) {
    printf("2.%p    ", ( void * )a);
}

结果你会得到相同的输出。

您可以简化代码，以便于理解底层内容。

考虑下面的代码sn-p

int a[11];
int *p = a;

如您所见，两个变量 a 和 p 占用不同的内存范围。所以这些 printf 调用会产生不同的结果

printf( "%p\n", &a );
printf( "%p\n", &p );

Answer 2

在main 中，a 是一个数组，&a 是存储该数组的地址。当main调用f时，f(a)中的a会自动转换为a的第一个元素的地址，并将该地址传递给f。

在f 中，a 是参数，&a 是存储该参数的地址。参数a的值设置为函数调用中传入的值，但&a是参数的地址，是值的副本。不是main中原来的a。

Answer 3

int a[] 在语法上与int* a 相同，它们都是指向整数（也称为 int 数组）的指针。因此正确的方法是没有&

void f(int a[]){
    printf("2.%x    ", a);
}
int main() {
    int a[11];
    printf("1.%x  ",a);
    f(a);
}

但是当 & 被删除时输出将是相同的。以及为什么不管数组大小相差12？

最初，您有&，它首先打印int a[11] 的地址。 然后将该数组的地址传递给f()，在那里它生成一个不同的指针，该指针也指向相同的地址。但是，这是两个不同的指针，因此当您打印实际指针的地址时，无论它们指向何处，它们显然都是不同的。

12（实际上是24，因为数字是十六进制）的区别是任意的，它只是告诉您这两个指针存储在彼此相距24字节的地址中

Answer 4

在您的程序中，函数f(int a[]) 中只有一个小错误

void f(int a[]) {
        printf("2.%x    ", &a);
}

函数f返回函数参数的地址，而不是它指向的地址。

由于掌握 C 中的指针是理解 C 语言的基本方面之一，因此不仅 C 语言本身，但机器架构和 CPU/内存功能的基础知识。

因此，在指针算术和搜索/调试中出错甚至可以驱动 经验丰富的 C 程序员为之疯狂，毫不奇怪，他们在 C++ 中被利用 static_cast、dynamic_cast 关键字，并在随后的计算机语言中完全删除（隐藏，即..）。

所以，我更进一步，重新编写了您的代码，更好地解释了该错误。

#include <stdio.h>

void  f(int b[]) {
printf("\n func call. print address:    %x", &b);  }
void f2(int b[]) {
printf("\n func call. print address(2): %x",  b);  }

int main()
{
  int *j, a[11];

     j = a;   // load address of 'a' array to int pointer 'j'
              // pointer 'j'
              //   j  = address of an array 'a'
              //  &j  = address of 'j' !!
          
     *j = 1;  // value of any 'int' that 'j'
              // points to is 1,so the value              
              // of a[0]= 1 

// ______ print values of 'j', 'a' ______
    // value is from address 'a'
    printf("\n1.) value of number (j)= %d",   *j);
    // int value of address 'a'
    printf("\n1.) value of number (a)= %d",  a[0]);

// ______ print addresses of 'j', 'a' ______
    // address of int variable 'j' that 
    // holds pointer to 'a'
    printf("\n\n2.) addr of number (j)= %x", &j);
    // address of 'a' array
    printf("\n2.) addr of number (a)= %x",   &a);
      
// ______ all of following adressess are the same ______
    // actual pointer (points to 'a' now)
    printf("\n\n3.) addr of 'j'   = %x",     j);
    // address od an array 'a'
    printf("\n3.) addr of 'a'   = %x",       a);
    // address of first int member in array a
    printf("\n3.) addr of 'a[0]'= %x\n", &a[0]);
      
    // ______ print them from function ______ (yours) ..
       f(&j); f(a);    // outputs an address of an argument passed to a function !!!     
          
    // ______ print them from function ______ (changed) ..
       f2(&j); f2(a);  // outputs an address that an argument points to !! 
                          // (holds address of)

      return 0;
  }

函数f 和f2 中的int b[] 是有意 而不是int a[]，因此很明显，参数是压入堆栈的变量的副本 - 不是实际变量 a.

程序输出：

1.) value of number (j)= 1

1.) value of number (a)= 1

2.) addr of number (j)= 5f826328
2.) addr of number (a)= 5f826330

3.) addr of 'j'   = 5f826330
3.) addr of 'a'   = 5f826330
3.) addr of 'a[0]'= 5f826330

 func call. print address:    5f826308
 func call. print address:    5f826308
 func call. print address(2): 5f826328
 func call. print address(2): 5f826330

Answer 5

原因是 main() 和 f() 将本地参数 a 放在内存中的不同位置，因为在某些时候，main() 和 f() 都在它们的执行中间，并且作为这两个参数都是它们各自定义的函数的局部变量，它们确实是不同的变量（尽管它们的名称相同）

Answer 6

当您编写int a[] 时，您指的是指针，因为数组是指针。 要引用a 指向的位置，您只需写a。当你写&a 时，你指的是指针本身的内存地址。指针本身的内存地址是不同的，因为您是按值传递指针（内存地址本身），这意味着它们在每个函数中都有一个副本。