C++反汇编学习笔记7——数组和指针以及他们的寻址

两年前写的，欢迎大家吐槽！

转载请注明出处。

1. 数组在函数内

先通过一个简单的例子来看一下数组和普通变量在初始化时的不同之处：

这是数组初始化：

42: int nArry[5] = {1, 2, 3, 4, 5};
0042B758 mov dword ptr [ebp-1Ch],1
0042B75F mov dword ptr[ebp-18h],2
0042B766 mov dword ptr [ebp-14h],3
0042B76D mov dword ptr [ebp-10h],4
0042B774 mov dword ptr [ebp-0Ch],5
下面是变量的初始化：
43: charcChar = 'A';
0042B77B mov byte ptr [ebp-25h],41h
44: floatfFloat = 1.0f;
0042B77F fld1
0042B781 fstp dword ptr [ebp-34h]
45: short sShort = 1;
0042B784 mov eax,1
0042B789 mov word ptr [ebp-40h],ax
46: intnInt = 2;
0042B78D mov dword ptr [ebp-4Ch],2
47: double dDouble = 2.0f;
0042B794 fld qword ptr [__real@4000000000000000 (47DC90h)]

0042B79A fstp qword ptr[ebp-5Ch]
数组中每个元素的数据类型是相同的，并且地址是连续的，通过这一点可以很容易的区别出在函数中的数组，而全局数组则在后面会讲到。Release版本的没有多大变化，和局部变量一样优化，但是数组不会因为被赋值常量而进行常量传递，代码如下：

.text:0042B758 mov [ebp+nArray], 1

.text:0042B75F mov [ebp+nArray+4], 2

.text:0042B766 mov [ebp+nArray+8], 3

.text:0042B76D mov [ebp+nArray+0Ch], 4

.text:0042B774 mov [ebp+nArray+10h], 5

现在再来看一下字符串，其实字符串就是字符数组，只是最后一个元素为‘\0’作为字符串结束标志而已。而字符串的初始化就是复制字节的过程，书上说VC++6.0编译器是通过寄存器来赋值的，因为每个寄存器拥有4字节，所以每次最多可以复制4字节的内容。但是我电脑上只有VS2010，它的编译器选择了直接将字符串常量写进文件然后将指针直接指向字符串常量装载入内存的地址。下面看这个例子使理解更加深刻一些：

55: char *szHello = "Hello world";
0042B74E mov dword ptr [szHello],offset string "Hello world" (47DD10h)

通过监视可以看到变量所在地址：

szHello的地址中存储的就是"Hello world"所在文件中的地址，再根据这个地址可以找到字符串：

2. 数组作为参数

首先来看个例子（Debug版本）：

这是main函数里面数组定义、初始化以及作为参数调用函数的代码

57: charszHello[20] = {0};
0042B758 mov byte ptr [ebp-1Ch],0 ；这个字节是数组的首地址
0042B75C xor eax,eax
；下面则是数组的剩余19个元素的初始化，利用eax寄存器进行赋值
0042B75E mov dword ptr [ebp-1Bh],eax
0042B761 mov dword ptr [ebp-17h],eax
0042B764 mov dword ptr [ebp-13h],eax
0042B767 mov dword ptr [ebp-0Fh],eax
；当不足4字节时编译器会做相应处理，这里的3字节被拆成2字节和1字节
0042B76A mov word ptr [ebp-0Bh],ax
0042B76E mov byte ptr [ebp-9],al
58: Show(szHello);
0042B771 lea eax,[ebp-1Ch]
0042B774 push eax ；取出数组首地址并入栈作为参数传到函数里面
0042B775 call Show (429FA5h)
0042B77A add esp,4
下面是show函数的定义：

9: void Show(char szBuff[])
10: {；先前代码略
11: strcpy(szBuff, "Hello World");
0042B66E push offset string "Hello World" (47DC6Ch) ；获取字符串常量的首地址
0042B673 mov eax,dword ptr [esp+8] ；获取参数
0042B676 push eax ；将其作为字符串复制函数的参数入栈
0042B677 call @ILT+1770(_strcpy) (4296EFh)
0042B67C add esp,8
12: printf(szBuff);
；printf函数代码略
13: }；后续代码略
从以上的例子可以很清楚的看到，数组作为函数的参数时是将数组的首地址入栈作为参数，然后根据首地址找到数组的每一个元素。

字符串处理函数在Debug版本下非常容易识别，但是在Release版本中字符串处理函数内联到程序中，没有call指令对函数进行调用，因此识别这些函数有一定的困难，但是可以根据反汇编的代码确定其内联代码的功能，并非必须还原出原函数。下面就用一个例子来具体说明：

先是C源代码：

main（）

{

charszHello[20] = {0};
Show(szHello);
}
void Show(charszBuff[])
{
strcpy(szBuff, "HelloWorld");
printf(szBuff);
}
首先对main函数中的代码用IDA P ro进行反汇编得到如下代码：

.text:00401030 aHello = byte ptr -18h ；这是一个数组，可以看到大小为0x14

.text:00401030 var_4 = dword ptr -4

.text:00401030

.text:00401030 push ebp

.text:00401031 mov ebp, esp

.text:00401033 sub esp, 18h

.text:00401036 mov eax, dword_40B014

.text:0040103B xor eax, ebp

.text:0040103D mov [ebp+var_4], eax

.text:00401040 xor eax, eax

；和Debug版本一样，下面是对数组的初始化

.text:00401042 mov [ebp+aHello], al

.text:00401045 mov dword ptr [ebp+aHello+1], eax

.text:00401048 mov dword ptr [ebp+aHello+5], eax

.text:0040104B mov dword ptr [ebp+aHello+9], eax

.text:0040104E mov dword ptr [ebp+aHello+0Dh], eax

.text:00401051 mov word ptr [ebp+aHello+11h], ax

.text:00401055 mov [ebp+aHello+13h], al

；取出数组首地址作为函数参数入栈

.text:00401058 lea eax, [ebp+aHello]

.text:0040105B push eax

；调用函数

.text:0040105C call sub_401000

；后续代码略

下面再来看看show函数的内部代码：

.text:00401000 arg_0 = dword ptr 8

.text:00401000

.text:00401000 push ebp

.text:00401001 mov ebp, esp

；这是非常关键的一步，可以看到数据段408140偏移的4字节数据复制到ecx寄存器

.text:00401003 mov ecx, ds:dword_408140

；接着再将数组首地址存入eax，虽然它本来就存着首地址，但是我也不知道为什么要这样

.text:00401009 mov eax, [ebp+arg_0]

；可以看到这一步实现了字符串的前四个字节的赋值，打开内存发现这正是“Hell”

.text:0040100C mov [eax], ecx

；与上同理，此处不再赘述

.text:0040100E mov edx, ds:dword_408144

.text:00401014 mov [eax+4], edx

.text:00401017 mov ecx, ds:dword_408148

；到此为止，所有字符串复制完毕，下面的代码便是printf函数调用和环境恢复了

.text:0040101D push eax

.text:0040101E mov [eax+8], ecx

.text:00401021 call sub_401074

.text:00401026 add esp, 4

.text:00401029 pop ebp

.text:0040102A retn

由于这段代码和书上给的反汇编代码完全不同，因此几乎都是我自己分析得到的，所以我花了好几个小时才完全弄明白，从这里可以看到，按照书上的东西似乎觉得自己都懂了，但是完全凭借自己来解决问题的时候却发现非常困难。这里仅仅是一段小小的字符串复制的代码就要花如此长的时间，足以显现反汇编是多么的不容易，至少对于我这种新手来说。所以这大概就是现在完全自动化的反编译器很少或是质量不高的原因，因为编译是一个不可逆的过程，想要正确地由二进制代码转换成汇编代码再转换成高级代码是很困难的。通过这段代码的独立分析，我还要不断实践以增加自己的经验。技术的进步正是靠着不断的积累！

看完了上面的代码，再来看个简单的（Release版本strlen函数）：

还是一样，贴出C源代码和反汇编代码，如下：

函数调用：

printf("%d \r\n", GetLen("Hello"));
函数定义：
//strlen函数分析
int GetLen(charszBuff[])
{
returnstrlen(szBuff);
}
main函数：

push offset aHello ;"Hello"；字符串常量存储在文件中，装载到内存指定位置

call sub_401000 ；调用GetLen函数

push eax

push offset aD ; "%d\r\n"

call sub_40103B；调用printf函数

add esp, 0Ch

xor eax, eax

retn

下面是GetLen函数定义的反汇编代码：

.text:00401000 arg_0 = dword ptr 8；这里就是字符串的首地址

.text:00401000

.text:00401000 push ebp

.text:00401001 mov ebp, esp

.text:00401003 mov eax, [ebp+arg_0]；将首地址存入eax中

.text:00401006 lea edx, [eax+1]；取出字符串的第二个元素的地址

.text:00401009 lea esp, [esp+0]；不知这条语句是何用意

.text:00401010

.text:00401010 loc_401010: ; CODE XREF: sub_401000+15j

.text:00401010 mov cl, [eax]；取出eax存储的地址中的字节

.text:00401012 inc eax；地址加1

.text:00401013 test cl, cl；相当于逻辑与，但不改变cl中的值

.text:00401015 jnz short loc_401010

；test与jnz共用，当cl为0时会使得标志寄存器FR中的标志位ZF=0，导致不跳转，循环结束，表示字符串中所有元素均已遍历，此时下一条语句只需将现在的地址eax减去原来的地址edx即为字符串的长度，相减后存储在eax作为返回值

.text:00401017 sub eax, edx

.text:00401019 pop ebp

.text:0040101A retn

总结：字符串处理函数经常内联到程序中，所以在看到相关代码时只需将其功能恢复即可。

3. 局部数组作为返回值

局部变量可以作为返回值，这是因为局部变量虽然也在函数的栈中，但是他会在函数结束之前将值存入某个寄存器中（一般是eax），但是局部数组作为返回值往往只会将他的首地址存入某个寄存器，这样一来当寄存器存储的地址内的区域里面的内容发生改变时便会造成原数据的改变。下面来举个例子方便理解（Debug版本）：

main函数中的调用：

74: printf("%s\r\n", RetArray());
0042B81E call RetArray (42A324h)
0042B823 push eax
0042B824 push offset string "%s\r\n" (47DC90h)
0042B829 call @ILT+4370(_printf) (42A117h)
0042B82E add esp,8
RetArray函数定义：

22: /*局部数组作为返回值*/
23: char* RetArray()
24: {；先前代码略
25: char szBuff[] = {"Hello World"};
；字符串复制
0042B708 mov eax,dword ptr [string "Hello World" (47DC6Ch)]

0042B70D mov dword ptr [ebp-14h],eax
0042B710 mov ecx,dword ptr ds:[47DC70h]
0042B716 mov dword ptr [ebp-10h],ecx
0042B719 mov edx,dword ptr ds:[47DC74h]
0042B71F mov dword ptr[ebp-0Ch],edx
26: returnszBuff;
0042B722 lea eax,[ebp-14h] ；将数组的首地址存入寄存器作为返回值
27: }；后续代码略
从上面的代码看，貌似并不会出现什么问题，在调用printf函数之前将eax的值作为参数入栈，然后将其所在的内存空间中的内容以字符串的形式输出。eax是安全的，但是以eax的值作为地址的内存空间并不安全。下面来看一下内存中的值的变化会更容易理解：

还没退出函数之前可以看到，查看其对应的内存：，可以看到里面的值就是Hello World。那么现在来看一下输出是多少，，其中的内存变成了。是的，这就是输出结果，和原来的字符串一点关系都没有，那这是什么原因呢？这里可以看到字符串是利用printf函数输出的，凡是函数在执行到时必定会有自己的栈，而程序的栈空间是每个函数都可以使用的，RetArray函数所使用的栈空间在后面又分配给了printf函数使用，此时很有可能导致字符串所在内存的不稳定，容易发生错误。因此以局部数组或是指针作为返回值是极不明智的，因为其所在区域在函数退出后不会有任何保护，非常容易造成最后的结果是错误的。

为了尽量避免上述所说的错误，可以使用全局数组、静态局部数组或上层函数中定义的局部数组来存储被调函数中需要返回的数组。下面就来简单的了解一下全局数组和静态局部数组。

全局数组的用法其实和全局变量相同。举一个简单的例子：

int g_nArry[5] = {1, 2, 3, 4, 5};
for (int i = 0; i< 5; i++)
{
printf("%d", g_nArry[i]);
}
用IDA Pro反汇编出的结果如下：

.text:0042DE0E mov [ebp+var_8], 0 ；变量i赋初值

.text:0042DE15 jmp short loc_42DE20

.text:0042DE17 ;---------------------------------------------------------------------------

.text:0042DE17

；loc_42DE17这块代码段是在第二次及以后的循环中做i++操作

.text:0042DE17loc_42DE17: ;CODE XREF: main+4Ej

.text:0042DE17 mov eax, [ebp+var_8]

.text:0042DE1A add eax, 1

.text:0042DE1D mov [ebp+var_8], eax

.text:0042DE20

.text:0042DE20loc_42DE20: ;CODE XREF: main+25j

.text:0042DE20 cmp [ebp+var_8], 5 ；和5比较大小

.text:0042DE24 jge short loc_42DE40 ；大于则跳出循环

.text:0042DE26 mov eax, [ebp+var_8]

.text:0042DE29 mov ecx, g_nArry[eax*4] ；利用下标寻址找到相应的数据

.text:0042DE30 push ecx

.text:0042DE31 push offset __real@4000000000000000 ;"%d"

.text:0042DE36 call j_printf

.text:0042DE3B add esp, 8 ；栈平衡

.text:0042DE3E jmp short loc_42DE17

.text:0042DE40 ;---------------------------------------------------------------------------

.text:0042DE40

.text:0042DE40loc_42DE40: ; CODEXREF: main+34j；这里就出了循环

再来看看全局数组：

.data:0048D000 g_nArry dd 1, 2, 3, 4, 5 ；这里我把它压缩到了一起形成一个数组

了解完了全局数组，再来简单的看一下静态局部数组，还是看一个例子：

83: intnOne;
84: intnTwo;
85: scanf("%d%d", &nOne,&nTwo);
；scanf函数代码略
86: static int g_snArry[5] = {nOne, nTwo, 0};
；查看变量g_snArry的地址为0x0048D464，所以下面的[$S1 (48D460h)]代表的就是标志字节
；将标志字节存入eax中
0042B5C3 mov eax,dword ptr [$S1(48D460h)]
0042B5C8 and eax,1
；这里判断静态局部数组是否曾经被初始化，若是被初始化则跳过下面的代码
0042B5CB jne main+70h (42B600h)
0042B5CD mov eax,dword ptr [$S1 (48D460h)]
0042B5D2 or eax,1 ；若没有被初始化那将其标志位置为1并在后面的代码中将其初始化
0042B5D5 mov dword ptr [$S1 (48D460h)],eax
0042B5DA mov eax,dword ptr [nOne]
0042B5DD mov dword ptr [g_snArry (48D464h)],eax
0042B5E2 mov eax,dword ptr [nTwo]
0042B5E5 mov dword ptr [g_snArry+4 (48D468h)],eax
0042B5EA mov dword ptr [g_snArry+8 (48D46Ch)],0
0042B5F4 xor eax,eax
0042B5F6 mov dword ptr[g_snArry+0Ch (48D470h)],eax
0042B5FB mov dword ptr [g_snArry+10h (48D474h)],eax
可以看到无论静态局部数组有多少个元素，都只进行一次初始化。

4. 下标寻址和指针寻址

数组可以通过下标和指针两种方式进行寻址。下标方式较为常见，效率也更高，指针方式不方便，效率也较低，因为它在访问数组时需要先取出指针中的地址，然后再对其进行偏移得到数组元素，而数组名则是一个常量地址，直接可以进行偏移计算。还是来看例子：

95: char *pChar = NULL;
0042B5B8 mov dword ptr [ebp-0Ch],0
96: charszBuff[10] = {0};
0042B5BF mov byte ptr [ebp-20h],0
0042B5C3 xor eax,eax
0042B5C5 mov dword ptr[ebp-1Fh],eax
0042B5C8 mov dword ptr[ebp-1Bh],eax
0042B5CB mov byte ptr [ebp-17h],al
97: scanf("%9s",szBuff);
0042B5CE lea eax,[ebp-20h]
0042B5D1 push eax
0042B5D2 push offset string "%9s" (47CC78h)
0042B5D7 call @ILT+3015(_scanf) (429BCCh)
0042B5DC add esp,8
98: pChar =szBuff;
0042B5DF lea eax,[ebp-20h]
0042B5E2 mov dword ptr [ebp-0Ch],eax
99: printf("%c",*pChar);
0042B5E5 mov eax,dword ptr [ebp-0Ch] ；取出指针变量中的地址
0042B5E8 movsx ecx,byte ptr [eax] ；在这个地址处取出数据
0042B5EB push ecx
0042B5EC push offset string "%c"(47CC94h)
0042B5F1 call @ILT+4110(_printf) (42A013h)
0042B5F6 add esp,8
100: printf("%c", szBuff[0]);
0042B5F9 movsx eax,byte ptr[ebp-20h] ；直接取出数据
0042B5FD push eax
0042B5FE push offset string "%c" (47CC94h)
0042B603 call @ILT+4110(_printf) (42A013h)
0042B608 add esp,8
从上面的代码可以看到，指针和下标寻址有着很明显的区别，指针需要进行两次寻址，而下标只需要一次，所以下标寻址的效率比较高，但是更为灵活，可以改变指针变量中的地址来访问其他内存，而数组在不越界的情况下是无法访问到数组以外的数据的。

这里再来讲讲下标值的不同类型会带来什么区别：

4.1下标值为整形常量

64: int nArry[5] = {1, 2, 3, 4, 5};
00428488 mov dword ptr [ebp-1Ch],1
0042848F mov dword ptr [ebp-18h],2
00428496 mov dword ptr [ebp-14h],3
0042849D mov dword ptr [ebp-10h],4
004284A4 mov dword ptr [ebp-0Ch],5
65:
66: printf("%d \r\n", nArry[2]);
004284AB mov eax,dword ptr [ebp-14h]
；printf函数分析略
需要将数组元素作为参数时直接计算出其下标值

4.2 下标值为为整形变量

69: printf("%d \r\n", nArry[argc]);
004284BC mov eax,dword ptr [ebp+8] ；首先取出argc的值，ebp+8为argc的地址
004284BF mov ecx,dword ptr [ebp+eax*4-1Ch] ；取出相应的数组元素

4.3 下标值为整形表达式

71: printf("%d \r\n", nArry[argc * 2]);
004284D1 mov eax,dword ptr [ebp+8]
004284D4 shl eax,1 ；这里先计算表达式的值
004284D6 mov ecx,dword ptr [ebp+eax*4-1Ch] ；这里和变量一样
当整形表达式的计算结果可以计算出来时，编译器会选择常量折叠，将表达式用常量代替。上面的是先进行表达式计算，然后再找到相应的数组元素。

以上就是数组的三种寻址方式，这三种方式都可以运用在指针寻址中。

4.4数组下标越界

C/C++中并不会对数组的越界访问进行检查，所以在使用下标时要时刻注意不要越界访问内存中的其他数据，从而造成程序崩溃甚至更严重的后果。越界下标的使用和正常下标一样，这里不再赘述。

5. 多维数组

多维数组其实在内存中也是线性存储的，只是在程序中编译器将其做了相应的处理而已。在学习C等高级语言时都已经学习了多维数组的原理，这里就来个简单的例子巩固一下：

103: int i =0;
0042B5B8 mov dword ptr [ebp-0Ch],0
104: int j =0;
0042B5BF mov dword ptr [ebp-18h],0
105: intnArray[4] = {1, 2, 3, 4};
；一维数组的初始化
0042B5C6 mov dword ptr[ebp-30h],1
0042B5CD mov dword ptr [ebp-2Ch],2
0042B5D4 mov dword ptr [ebp-28h],3
0042B5DB mov dword ptr [ebp-24h],4
106: intnTwoArray[2][2] = {{1, 2},{3, 4}};
；二维数组的初始化
0042B5E2 mov dword ptr [ebp-48h],1
0042B5E9 mov dword ptr [ebp-44h],2
0042B5F0 mov dword ptr[ebp-40h],3
0042B5F7 mov dword ptr[ebp-3Ch],4
107: scanf("%d%d", &i, &j);
；scanf函数调用略
108: printf("nArray= %d\r\n", nArray[i]);
0042B613 mov eax,dword ptr [ebp-0Ch] ；取出i
0042B616 mov ecx,dword ptr [ebp+eax*4-30h] ；计算偏移并取出其中元素
0042B61A push ecx
0042B61B push offset string "nArray = %d\r\n" (47CCA8h)
0042B620 call @ILT+4110(_printf) (42A013h)
0042B625 add esp,8
109: printf("nTwoArray = %d\r\n", nTwoArray[i][j]);
0042B628 mov eax,dword ptr [ebp-0Ch] ；取i
0042B62B lea ecx,[ebp+eax*8-48h] ；8为每一个一维数组的大小，这里是取得第i个一维数组的首地址
0042B62F mov edx,dword ptr [ebp-18h] ；取j
0042B632 mov eax,dword ptr [ecx+edx*4] ；取出其中的元素
0042B635 push eax
0042B636 push offset string "nTwoArray = %d\r\n" (47CC94h)

0042B63B call @ILT+4110(_printf) (42A013h)
0042B640 add esp,8
这里一维数组和二维数组有着明显的区别，一维数组直接根据偏移量取出数组中的元素，二维数组则需要先计算第i个一维数组的首地址然后根据j偏移量来得到元素。

当有一个下标为常量时:

112: int i =0;
0042B5B8 mov dword ptr [ebp-0Ch],0
113: intnTwoArray[2][2] = {{1, 2},{3, 4}}; //二维数组
0042B5BF mov dword ptr [ebp-24h],1
0042B5C6 mov dword ptr[ebp-20h],2
0042B5CD mov dword ptr [ebp-1Ch],3
0042B5D4 mov dword ptr [ebp-18h],4
114: scanf("%d",&i);
;scanf函数代码略
115: printf("nTwoArray= %d\r\n", nTwoArray[1][i]);
;这里ebp-1Ch是由ebp-24h+1*8计算而来的,利用了常量折叠
0042B5EC mov eax,dword ptr [ebp-0Ch]
0042B5EF mov ecx,dword ptr [ebp+eax*4-1Ch]
0042B5F3 push ecx
0042B5F4 push offset string"nTwoArray = %d\r\n" (47CC94h)
0042B5F9 call @ILT+4110(_printf) (42A013h)
0042B5FE add esp,8
上面分析了Debug版本的一维数组和二维数组之间的区别，现在来看看经编译器优化后的数组初始化以及Release版本下的数组寻址过程：

var_2C=dword ptr -2Ch ；j

var_28= dword ptr -28h ；i

var_24= dword ptr -24h ；二维数组首地址

var_20= dword ptr -20h

var_1C=dword ptr -1Ch

var_18= dword ptr -18h

var_14= dword ptr -14h ；一维数组首地址

var_10= dword ptr -10h

var_C= dword ptr -0Ch

var_8= dword ptr -8

var_4= dword ptr -4 ；不知道这个是干嘛用的，从后面的代码分析应该是检验或是校正之类的



push ebp

mov ebp, esp

sub esp, 2Ch

mov eax, dword_40D014

xor eax, ebp

mov [ebp+var_4], eax

；以上代码不知道是干嘛的

xor eax, eax ；将eax置0

mov [ebp+var_28], eax ；i置0

mov [ebp+var_2C], eax；j置0

mov eax, 4

mov ecx, 3

；两个数组的最后一个元素均被置为4，其他元素初始化同理

mov [ebp+var_8], eax

mov [ebp+var_18], eax

lea eax, [ebp+var_2C] ；取j作为scanf的参数

mov [ebp+var_C], ecx；置为3

mov [ebp+var_1C], ecx

push eax

lea ecx, [ebp+var_28]；同上

mov edx, 2

push ecx

push offset aDD ; "%d%d"

mov [ebp+var_14], 1 ；置为1

mov [ebp+var_10], edx ；置为2

mov [ebp+var_24], 1

mov [ebp+var_20], edx

；到此为止两个数组的所有成员均被初始化

call sub_4011D0；调用scanf函数

mov edx, [ebp+var_28] ；取出i

mov eax, [ebp+edx*4+var_14] ；得到一维数组相应元素

push eax

push offset aNarrayD ; "nArray = %d\r\n"

call sub_401096 ；调用printf函数

mov ecx, [ebp+var_2C] ；取出j

mov edx, [ebp+var_28] ；取出i

lea eax, [ecx+edx*2] ；这里并不是取第i个一维数组的首地址，而是计算出当这个元素相对于数组首地址的偏移个数，即把他转化之后相当于就是一个一维数组而不是二维数组

mov ecx, [ebp+eax*4+var_24] ；取出数组中的元素

push ecx

push offset aNtwoarrayD ; "nTwoArray = %d\r\n"

call sub_401096

下面的代码应该就是用到了var_4变量，但是我不知道它的实际用途

mov ecx, [ebp+ var_4]

xor ecx, ebp

add esp, 1Ch

xor eax, eax

call sub_4011ED

mov esp, ebp

pop ebp

retn

正如上面的代码所表示的，内存给局部变量分配空间是从大到小分配的，不仅如此，在O2情况下，当一维数组和二维数组初始化的内容相同时便会一起进行初始化，并且编译器不将所有的初始化语句都放在一起是为了减少指令之间的相关性，使得指令能够像流水线那样执行，提高程序的效率。

其他多维数组的分析和二维数组相同，都是逐渐降维最后转化成低维数组进行处理，这里不再赘述。

6. 指针数组

指针数组就是存放同一类型指针的数组，数组的每个元素都存放着地址，一般用于处理若干个字符串的操作（如二维字符数组）。它和数组的区别就在于在取出数组中的元素之后还要进行一次间接寻址。下面就用一个例子来加深理解。

126: char * pBuff[3] = {
127: "Hello ",
0042840E mov dword ptr [pBuff],offset string "Hello " (472CA0h)

；将字符串的首地址存入数组中，下同
128: "World ",
00428415 mov dword ptr [ebp-0Ch],offset string "World " (472C98h)
129: "!\r\n"
130: };
0042841C mov dword ptr [ebp-8],offset string"!\r\n" (472C94h)

131: for (int i = 0; i < 3; i++) {
；for循环代码略
132: printf(pBuff[i]);
0042843B mov eax,dword ptr [i] ；取i
0042843E mov ecx,dword ptr pBuff[eax*4] ；找到相应的数组中的地址元素并放到ecx中
00428442 push ecx
00428443 call @ILT+3900(_printf) (426F41h)
00428448 add esp,4
133: }
指针数组和二维字符数组有着很明显的区别，若是在初始化阶段，二维字符数组是将每个字符数据赋值，而指针数组仅仅是将字符串的首地址存入数组中。
7. 数组指针

这是指向数组的一个指针变量，里面存储的是数组的首地址。看一个简单的例子：

charcArray[3][10] = {
"Hello ",
"World ",
"!\r\n"
};
；二维字符数组初始化略
146: char (*pArray)[10] = cArray;
00428473 lea eax,[ebp-28h] ；取出cArray数组的首地址
00428476 mov dword ptr [ebp-34h],eax ；将地址存入pArray中
147: for (int i = 0; i < 3; i++)
；for循环代码略
148: {
149: printf(*pArray);
00428491 mov eax,dword ptr [ebp-34h]
00428494 push eax
00428495 call @ILT+3900(_printf) (426F41h)
0042849A add esp,4
150: pArray++;
0042849D mov eax,dword ptr [ebp-34h]
004284A0 add eax,0Ah
；这里每次pArray+1都是使地址+10，这是因为pArray的指针类型是长度为10的字符数组
004284A3 mov dword ptr [ebp-34h],eax ；将计算过后的地址重新放入pArray指针变量中
151: }
指针地址的运算公式：指针变量的地址 += （ sizeof（指针类型） * 数值 ），这里的指针类型为char[10]，所以每次指针变量+1时就相当于变量中的地址+10。

下面再来看一下二级指针以及他和指向二维字符数组的指针的区别。二级指针由于其指针的类型是指针类型，所以每次+1都只会在地址上+4，而指向二维字符数组的指针的类型是数组，所以需要根据数组的大小来决定加多少。下面来看一个输出main函数参数的例子：

voidmain(int argc, char *argv[ ], char *envp[ ] )
153: {
154: for (int i = 1; i < argc; i++)
；for循环代码略
155: {
156: printf(argv[i]);
00428428 mov eax,dword ptr [i] ；取i
0042842B mov ecx,dword ptr [argv] ；取出参数argv首地址
0042842E mov edx,dword ptr [ecx+eax*4] ；获得第i个argv参数的首地址
00428431 push edx
00428432 call @ILT+3900(_printf) (426F41h)
00428437 add esp,4
157: }
158:}

从上面可以看到argv是二级指针，取出里面的元素时必须要进行两次取址

8. 函数指针

call指令会跳转到函数的首地址处然后执行函数内部的代码，这样它也可以使用指针来调用。还是看一个简单的例子：

162: void(__cdecl *pShow)(void) = Show;
；函数名就是函数的首地址，是一个常量
0042840E mov dword ptr [pShow],offset Show (427027h)
163:
164: pShow();
00428415 mov esi,esp
00428417 call dword ptr [pShow] ；通过指针间接调用函数
；下面两句都是栈平衡检查，Debug版本所特有
0042841A cmp esi,esp
0042841C call @ILT+3020(__RTC_CheckEsp)(426BD1h)
165: Show();
00428421 call Show (427027h) ；直接函数调用
函数指针是比较特殊的指针，它保存的是代码段而非数据段的地址，所以不存在地址偏移的情况，编译器会在编译阶段对函数指针进行检查以防止其进行加减等没有意义的运算。
上面的函数的返回值和参数均为void，下面再来看一个有返回值和参数的函数指针：
167: int(__stdcall *pShow)(int) = Show;
；在定义指针时就定义返回值和参数
0042840E mov dword ptr [pShow],offset Show (4262F3h)
168: intnRet = pShow(5);
00428415 mov esi,esp
00428417 push 5
00428419 call dword ptr [pShow] ；间接调用函数
；下面是栈平衡检查
0042841C cmp esi,esp
0042841E call @ILT+3020(__RTC_CheckEsp) (426BD1h)
00428423 mov dword ptr [nRet],eax
169: printf("ret= %d \r\n", nRet);
00428426 mov eax,dword ptr [nRet]
00428429 push eax
0042842A push offset string "ret = %d \r\n"(472C90h)
0042842F call @ILT+3900(_printf) (426F41h)
00428434 add esp,8
一个函数指针只能存储同一种类型的函数的地址，包括函数的参数和返回值，否则无法传递参数和返回值，也无法进行栈平衡检查。