C 为什么这个指针似乎指向它自己？

我正在努力掌握C语言中的指针，并努力理解为什么我会得到一个奇怪的输出

我的代码是：

intmain（）{

inta[3][6]；
int i，j，k=0；
对于（i=0；i<3；i++）{
对于（j=0；j<6；j++）{
a[i][j]=k++；
}
}
int c=5；
int*p=&c；
printf（“p的地址=%p\n”，&p）；
printf（“p=%p\n”，p）；
printf（“c=%p\n”的地址，&c）；
printf（“a[2]=%p\n”的地址，&a[2]）；
printf（“a[2][0]=%p\n”的地址，&a[2][0]）；
printf（“a[2]=%p\n”，a[2]）；
printf（“a[2][0]=%d\n”，a[2][0]）；
返回0；

}

我得到的结果是：

int main( void )
{
    int b[5];

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

    printf( "b+1    = %p\n", b+1    );
    printf( "(&b)+1 = %p\n", (&b)+1 );
}

p=0x7fff6cbabf88的地址 p=0x7fff6cbabf90 c=0x7fff6cbabf90的地址 [2]的地址=0x7fff6cbabf70 [2][0]=0x7fff6cbabf70的地址 a[2]=0x7fff6cbabf70 [2][0]=12

---

这似乎表明

a[2]==&a[2]

但这肯定是不正确的？

从更简单的事情开始，像这样

a        is a pointer to     int [6]
a[i]     is a pointer to     int
a[i][j]  is an int

&a       is a pointer to     int [3][6]
&a[i]    is a pointer to     int [6]
&a[i][j] is a pointer to     int

编译器将

b

视为指向int的

指针，而
&b
是指向5个int的数组的
指针。因此，将1添加到
b
会将地址更改4（假设为32位int），而将1添加到
&b
会将地址更改20位小数


一旦您理解了这一点，您就可以使用
a[3][6]
数组将自己击倒

int a[3][6];

从简单的事情开始，像这样

a        is a pointer to     int [6]
a[i]     is a pointer to     int
a[i][j]  is an int

&a       is a pointer to     int [3][6]
&a[i]    is a pointer to     int [6]
&a[i][j] is a pointer to     int

编译器将
b
视为指向int
的
指针，而
&b
是指向5个int的数组的
指针。因此，将1添加到
b
会将地址更改4（假设为32位int），而将1添加到
&b
会将地址更改20位小数


一旦您理解了这一点，您就可以使用
a[3][6]
数组将自己击倒

int a[3][6];

数组名称相当于指向数组第一项的指针：
arr==&arr[0]


您的
a
是二维数组，因此
a[0]
或
a[2]
是一维数组，

因此，数组名相当于指向数组第一项的指针：
arr==&arr[0]
您的
a
是二维数组，因此
a[0]
或
a[2]
是一维数组，

因此
a[2]==&a[2][0]
如果使用数组的标识符，在大多数情况下，它会衰减为指向第一个元素的指针

所以


&a
是
int（*）[3][6]
，因此
sizeof（*&a）
将是
18*sizeof（int）
a
和
&a[0]
都是
int（*）[6]
，因此
sizeof（*a）
和
sizeof（*&a[0]）
将是
6*sizeof（int）
a[0]
和&a[0][0]都是
int*
，因此
sizeof（*a[0]）
和
sizeof（*&a[0][0]）
将是
6*sizeof（int）

（请注意，
sizeof
表达式中出现的所有
*&
都可以优化；为了更好地理解，我将它们留在这里。）

但是所有提到的指针都指向相同的位置

请务必注意，指针由地址和类型（长度）组成，两者都是相关的。
如果使用数组的标识符，在大多数情况下，它会衰减为指向第一个元素的指针

所以


&a
是
int（*）[3][6]
，因此
sizeof（*&a）
将是
18*sizeof（int）
a
和
&a[0]
都是
int（*）[6]
，因此
sizeof（*a）
和
sizeof（*&a[0]）
将是
6*sizeof（int）
a[0]
和&a[0][0]都是
int*
，因此
sizeof（*a[0]）
和
sizeof（*&a[0][0]）
将是
6*sizeof（int）

（请注意，
sizeof
表达式中出现的所有
*&
都可以优化；为了更好地理解，我将它们留在这里。）

但是所有提到的指针都指向相同的位置

始终注意指针由地址和类型（长度）组成，两者都是相关的。
a[2]
具有类型
int[6]
<代码>&a[2]
具有类型
int（*）[6]
。如果你有一个指向一个人的指针和一个指向火车的指针；把那个人放进火车里。。。两个指针指向同一个东西吗？？？心智==崩溃！因此，如果你让上面的指针指向下一个东西，它们会指向完全不同的方向（下一个人和下一列火车）。我的意思是，指针是通过地址和它们指向的类型来识别的。我想我的问题是，我正在尝试使用数组名的指针算法，而数组名不是指针。@潜伏者：
a[n]
和
&a[n]
不是同义词！第一个是数组（检查
sizeof a[n]
），第二个是指针（检查
sizeof&a[n]
）。数组有时会转换为指向其第一个元素的指针。当转换发生时，
a[n]
与
&a[n][0]
a[2]
具有类型
int[6]
<代码>&a[2]
具有类型
int（*）[6]
。如果你有一个指向一个人的指针和一个指向火车的指针；把那个人放进火车里。。。两个指针指向同一个东西吗？？？心智==崩溃！因此，如果你让上面的指针指向下一个东西，它们会指向完全不同的方向（下一个人和下一列火车）。我的意思是，指针是通过地址和它们指向的类型来识别的。我想我的问题是，我正在尝试使用数组名的指针算法，而数组名不是指针。@潜伏者：
a[n]
和
&a[n]
不是同义词！第一个是数组（check
sizeof a[n]
），第二个是指针（check
）