这三个值为什么一样大啊，真是很奇怪

[kevin820601]

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

typedef unsigned long ulong;

int main()
{	
	ulong ulArray[10] = {0};
	
	void* addr1 = &ulArray; /* 1 */

	void* addr2 = &(ulArray[0]); /* 2 */

	void* addr3 = ulArray; /* 3 */

	printf("%d,%d,%d",(ulong)addr1,(ulong)addr2,(ulong)addr3);
	
	return 0;
}

2,3相等好理解，1,2相等很难理解啊，呵呵

[sagegz]

数组名可以看成数组中第一个元素的地址.

[kevin820601]

 void* addr1 = &ulArray; /* 1 */

 void* addr2 = &(ulArray[0]); /* 2 */

其实1，2相等也很好理解啊，这样证明吧:

ulong *p1 == ulArray;

ulong *p2 == ulArrat[0] ==  p1 + 0;

所以p1 == p2 


所以&p1 == &p2,但是这样证明很没意思啊，纯数学了，希望得到从内存角度得到解释，呵呵

[HelloDan]

都是指针的值，即地址

[kevin820601]

[Quote=引用 1 楼 sagegz 的回复:]
数组名可以看成数组中第一个元素的地址.
[/Quote]

你这个我知道啊，所以2，3是相等的，但是1，2 相等是不能用这个解释的，不是吗？

[lightnut]

数组名就是数组中第一个元素的地址!!

[waizqfor]

ulong ulArray[10] = {0};
    
    void* addr1 = &ulArray; /* 1 */

    void* addr2 = &(ulArray[0]); /* 2 */

    void* addr3 = ulArray; /* 3 */

3个都是数组的首地址啊
void* addr1 = &ulArray;//数组名 相当于数组首地址啊
void* addr2 = &(ulArray[0]); //取数组的第一个元素 再取地址 其实一样的
void* addr3 = ulArray;//跟第一个一样

[kevin820601]

[size=240px]这个说吧，1很3相等是不是相当的匪夷所思啊[/size]

[kevin820601]

&ulArray == ulArray太不可思议了吧

[The_facE]

如果你知道二维数组的名字和它的第一列首地址相等，应该就容易明白了。
a[M][N];
a的值等于a[0]。

[vincent_1011]

[Quote=引用 9 楼 The_facE 的回复:]
如果你知道二维数组的名字和它的第一列首地址相等，应该就容易明白了。
a[M][N];
a的值等于a[0]。
[/Quote]

楼上有理，但是要小心
&ulArray == ulArray 虽然相等，当他们 +1的时候却不同了，注意！

[The_facE]

[Quote=引用 10 楼 vincent_1011 的回复:]
引用 9 楼 The_facE 的回复:
如果你知道二维数组的名字和它的第一列首地址相等，应该就容易明白了。
a[M][N];
a的值等于a[0]。


楼上有理，但是要小心
&ulArray == ulArray 虽然相等，当他们 +1的时候却不同了，注意！
[/Quote]

它俩相等但不是同一种东西，这个忘了说了，谢谢提醒。

[deerwin1986]

第一个是数组的地址
后两个是数组第一个元素的地址(第三个是数组指针退化)
虽然值一样 但是意义不一样...

[ysysbaobei]

顶

[ysysbaobei]

顶

[yuzl32]

反汇编后就很清楚了！

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

typedef unsigned long ulong;

int main()
{    
    ulong ulArray[10] = {0};
    
    void* addr1 = &ulArray; /* 1 */

    void* addr2 = &(ulArray[0]); /* 2 */

    void* addr3 = ulArray; /* 3 */

    printf("%d,%d,%d",(ulong)addr1,(ulong)addr2,(ulong)addr3);
    
    return 0;
}

.text:00401000 ; int __cdecl main(int argc, const char **argv, const char *envp)
.text:00401000 _main           proc near               ; CODE XREF: ___tmainCRTStartup+15Ap
.text:00401000
.text:00401000 var_34          = dword ptr -34h
.text:00401000 var_30          = dword ptr -30h
.text:00401000 var_2C          = dword ptr -2Ch
.text:00401000 var_28          = dword ptr -28h
.text:00401000 var_24          = dword ptr -24h
.text:00401000 var_20          = dword ptr -20h
.text:00401000 var_1C          = dword ptr -1Ch
.text:00401000 var_18          = dword ptr -18h
.text:00401000 var_14          = dword ptr -14h
.text:00401000 var_10          = dword ptr -10h
.text:00401000 var_C           = dword ptr -0Ch
.text:00401000 var_8           = dword ptr -8
.text:00401000 var_4           = dword ptr -4
.text:00401000 argc            = dword ptr  8
.text:00401000 argv            = dword ptr  0Ch
.text:00401000 envp            = dword ptr  10h
.text:00401000
.text:00401000                 push    ebp
.text:00401001                 mov     ebp, esp
.text:00401003                 sub     esp, 34h
.text:00401006                 mov     [ebp+var_28], 0 ; 数组初始化,ulArray[0]=0
.text:0040100D                 xor     eax, eax
.text:0040100F                 mov     [ebp+var_24], eax ; 数组初始化,ulArray[1]=0
.text:00401012                 mov     [ebp+var_20], eax ; 数组初始化,ulArray[2]=0
.text:00401015                 mov     [ebp+var_1C], eax ; 数组初始化,ulArray[3]=0
.text:00401018                 mov     [ebp+var_18], eax ; 数组初始化,ulArray[4]=0
.text:0040101B                 mov     [ebp+var_14], eax ; 数组初始化,ulArray[5]=0
.text:0040101E                 mov     [ebp+var_10], eax ; 数组初始化,ulArray[6]=0
.text:00401021                 mov     [ebp+var_C], eax ; 数组初始化,ulArray[7]=0
.text:00401024                 mov     [ebp+var_8], eax ; 数组初始化,ulArray[8]=0
.text:00401027                 mov     [ebp+var_4], eax ; 数组初始化,ulArray[9]=0
.text:0040102A                 lea     ecx, [ebp+var_28] ; ebp+var_28=数组ulArray的第0个元素地址
.text:0040102D                 mov     [ebp+var_34], ecx ; [ebp+var_34]=&ulArray[0],即代码中的addr1 = &ulArray;
.text:00401030                 lea     edx, [ebp+var_28]
.text:00401033                 mov     [ebp+var_2C], edx ; 同理：代码中的addr2 = &(ulArray[0])
.text:00401036                 lea     eax, [ebp+var_28]
.text:00401039                 mov     [ebp+var_30], eax ; void* addr3 = ulArray;
.text:0040103C                 mov     ecx, [ebp+var_30]
.text:0040103F                 push    ecx             ; 压入addr3
.text:00401040                 mov     edx, [ebp+var_2C]
.text:00401043                 push    edx             ; 压入addr2
.text:00401044                 mov     eax, [ebp+var_34]
.text:00401047                 push    eax             ; 压入addr1
.text:00401048                 push    offset aDDD     ; "%d,%d,%d"
.text:0040104D                 call    sub_40105B      ; printf函数输出
.text:00401052                 add     esp, 10h
.text:00401055                 xor     eax, eax
.text:00401057                 mov     esp, ebp
.text:00401059                 pop     ebp
.text:0040105A                 retn
.text:0040105A _main           endp

[old-six-programmer]

首先可以明确的是
&ulArray ！= ulArray

&ulArray的类型是： ulong(*)[10]
ulArray的类型是： ulong[10]

可以看出&ulArray指向整个数组
ulArray指向数组的第一个元素

这就是为什么程序把它们声明为void*的原因
因为它们本质上都是一个指针

其余的楼上都已经解释的很清楚了

[lq651659889]

1,2到还是很好理解的啊！数组首地址就是数组第一个元素的地址啊！

[机智的呆呆]

#include <typeinfo>
#include <stdio.h>
#include <string.h>
#include <stdlib.h> 
typedef unsigned long ulong; 
int main() 
{ 
   ulong ulArray[10] = {0};
   void* addr1 = &ulArray; /* 1 */  
   void* addr2 = &(ulArray[0]); /* 2 */  
   void* addr3 = ulArray; /* 3 */  
   printf("%d,%d,%d",(ulong)addr1,(ulong)addr2,(ulong)addr3);
   printf("\n"); 
   printf("%s,%s,%s",typeid(&ulArray).name(),typeid(&ulArray[0]).name(),typeid(ulArray).name());
   system("pause");
   return 0;
}