静态数组与动态数组

数组是程序设计中是一个非常重要的概念。数组是一个用于收集大量类似数据的容器， 

以及其每一个元素能被相同处理过程迭代来处理的一个抽象体。 
创建数组一般有三种方式：全局/静态范围的数组，局部变量数组，申请堆空间来创建数组。 
其中，全局/静态范围的数组，以及局部变量属于静态数组。 
而申请堆空间来创建数组的属于动态数组。 



a[7]与p1_a[7]是一样的么？ 

静态两维数组的排列顺序 

动态两维数组的排列顺序 

数组与指针 

各种数组的声明方式 

静态数组和动态数组在内存的组织方式 

杂谈，不为人知的数组表达方式 

数组的迭代与性能影响 



a[7]与p1_a[7]是一样的么？ 
首先声明几个数组： 

C代码  

1. int g_a[10];    // 全局变量数组  
2.   
3. int main(int argc, char** argv)  
4. {  
5.     int a[10];    // 局部变量数组  
6.     static int s_a[10];    // 静态局部变量数组  
7.     int *p1_a, *p2_a;    // 数组指针  
8.   
9.     // 为动态数组申请空间  
10.     p1_a = (int*)malloc(sizeof(int) * 10);  
11.     p2_a = new int[10];  
12.   
13.     // 为数组赋值  
14.     a[7] = 0;  
15.     s_a[7] = 0;  
16.     g_a[7] = 0;  
17.     p1_a[7] = 0;  
18.     p2_a[7] = 0;  
19.   
20.     // 释放空间，并且将指针置0  
21.     delete[] p2_a;  
22.     free(p1_a);  
23.     p1_a = p2_a = 0;  
24. }  

上述程序中，5个数组的在赋值的时候除了变量名以外几乎都是一模一样的，是不是他们的实现也一样了呢？ 
答案是否定的，动态数组和静态数组虽然在使用时看起来没有什么差别，但他们实现是不一样的。 
反汇编看一下他们的代码。 
数组类型 C/C++代码 汇编实现 简略说明 
局部变量 a[7] = 0; MOV DWORD PTR SS:[EBP-C], 0  采用EBP在堆栈定位变量 
[EBP - 28] a[0] 
... 
[EBP - 4] a[9] 

静态局部变量 s_a[7] = 0; MOV DWORD PTR DS:[4C5E5C], 0  静态变量会被放到数据.data段中 
全局变量 g_a[7] = 0; MOV DWORD PTR DS:[4C5E84], 0  全局变量和静态变量一样， 
会被放到数据.data段中 
数组指针 
（malloc） p1_a[7] = 0; MOV EAX, DWORD PTR SS:[EBP-2C] 
MOV DWORD PTR DS:[EAX+1C], 0 
对于数组指针，要进行两次寻址 
0x1C / 4 = 7 

数组指针 
（new） p2_a[7] = 0; MOV EAX, DWORD PTR SS:[EBP-30] 
MOV DWORD PTR DS:[EAX+1C], 0 
同上 

根据汇编的结果可见，静态数组都采用了一次寻址， 
而动态数组都是两次寻址，这和动态数组本身实现是有关系的。 
静态数组的变量本身就是数组第一个元素的地址。 
动态数组的变量存放的是一根指向到申请空间的首址指针。 



静态两维数组的排列顺序 
首先是静态数组，在C/C++中，其实没有正真的两维概念， 
对于所有静态数组来说，都是一维的，考虑以下的例子 
int a[35]和int b[7][5] 
对于前者，就是包含35个int类型值的数组 
而对于后者，可以理解为b是一个拥有7个数组类型的数组， 
每个数组类型又是一个拥有5个int类型值的数组。 
可以得出的结果就是两个数组在内存中的分布其实是一样的。 


用简单的程序来验证一下： 

C代码  

1. int a[35];  
2. int b[7][5];  
3.   
4. a[0] = 4;  
5. a[1] = 5;  
6. a[34] = 6;  
7. b[0][0] = 7;  
8. b[0][1] = 8;  
9. b[1][0] = 9;  
10. b[6][4] = 10;  
11.   
12. a[0] = 4;  
13. a[1] = 5;  
14. a[34] = 6;  
15.  MOV DWORD PTR SS:[EBP-8C], 4  
16. MOV DWORD PTR SS:[EBP-88], 5  
17. MOV DWORD PTR SS:[EBP-4], 6  
18.  0x8C - 0x04 = 0x88    
19. b[0][0] = 7;  
20. b[0][1] = 8;  
21. b[1][0] = 9;  
22. b[6][4] = 10;  
23.  MOV DWORD PTR SS:[EBP-118], 7  
24. MOV DWORD PTR SS:[EBP-114], 8  
25. MOV DWORD PTR SS:[EBP-104], 9  
26. MOV DWORD PTR SS:[EBP-90], 0A  
27.  0x118 - 0x90 = 0x88    

以上汇编的结果表明，两维数组的实现就是转化成了一维。 


如果对两维的概念比较清楚的话，再看两维的排列顺序就不难了 
首先是一维的情况（在内存中a[0]和a[1]是连续的） 
a[0] a[1] a[2] …… a[33] a[34] 

接着是两维（在内存中b[0][0]和b[0][1]是连续的，b[0][4]与b[1][0]是连续的，但b[0][0]和b[1][0]不是连续的） 
b[0][0] b[0][1] b[0][2] b[0][3] b[0][4] 
b[1][0] b[1][1] b[1][2] b[1][3] b[1][4] 
b[2][0] b[2][1] b[2][2] b[2][3] b[2][4] 
b[3][0] b[3][1] b[3][2] b[3][3] b[3][4] 
b[4][0] b[4][1] b[4][2] b[4][3] b[4][4] 
b[5][0] b[5][1] b[5][2] b[5][3] b[5][4] 
b[6][0] b[6][1] b[6][2] b[6][3] b[6][4] 

以此类推，三维的情况下，首先是第三维的增长，然后再是第二维，最后才是第一维 



动态两维数组的排列顺序 
首先动态两维数组的创建方式有所不同，以下是经典的创建方法： 

C代码  

1. int* pa;  
2. int** pb;  
3.   
4. // 申请空间  
5. pa = new int[35];  
6. pb = new int*[7];  
7. for (int i = 0; i < 7; i++)  
8. {  
9.     pb[i] = new int[5];  
10. }  
11.   
12. // 赋值操作  
13. pa[0] = 4;  
14. pa[1] = 5;  
15. pa[34] = 6;  
16. pb[0][0] = 7;  
17. pb[0][1] = 8;  
18. pb[1][0] = 9;  
19. pb[6][4] = 10;  
20.   
21. // 释放空间  
22. delete[] pa;  
23. for (int i = 0; i < 7; i++)  
24. {  
25.     delete[] pb[i];  
26. }  
27. delete[] pb;  
28.   
29.   
30. 汇编分析  
31. pa[0] = 4;  
32.   
33. pa[1] = 5;  
34.   
35. pa[34] = 6;  
36.   
37.  MOV EAX, DWORD PTR SS:[EBP-11C]  
38. MOV DWORD PTR DS:[EAX], 4  
39. MOV EAX, DWORD PTR SS:[EBP-11C]  
40. MOV DWORD PTR DS:[EAX+4], 5  
41. MOV EAX, DWORD PTR SS:[EBP-11C]  
42. MOV DWORD PTR DS:[EAX+88], 6  
43.  两次寻址  
44.    
45. pb[0][0] = 7;  
46.   
47.   
48. pb[0][1] = 8;  
49.   
50.   
51. pb[1][0] = 9;  
52.   
53.   
54. pb[6][4] = 10;  
55.   
56.   
57.  MOV EAX, DWORD PTR SS:[EBP-120]  
58. MOV ECX, DWORD PTR DS:[EAX]  
59. MOV DWORD PTR DS:[ECX], 7  
60. MOV EAX, DWORD PTR SS:[EBP-120]  
61. MOV ECX, DWORD PTR DS:[EAX]  
62. MOV DWORD PTR DS:[ECX+4], 8  
63. MOV EAX, DWORD PTR SS:[EBP-120]  
64. MOV ECX, DWORD PTR DS:[EAX+4]  
65. MOV DWORD PTR DS:[ECX], 9  
66. MOV EAX, DWORD PTR SS:[EBP-120]  
67. MOV ECX, DWORD PTR DS:[EAX+18]  
68. MOV DWORD PTR DS:[ECX+10], 0A  

三次寻址！ 
牵涉到两个堆地址：[EAX+n]和[ECX+n] 
从内存连续性角度来分析的话， 
pb[0][0]和pb[0][1]是连续的， 
pb[0]和pb[1]也是连续的， 
因为其中存放的不再是数组了，而是数组指针 
但pb[0][4]和pb[1][0]不再连续 




动态数组在内存中的分布大致如下，首先来看看一维：（pa[0]和pa[1]还是连续的） 
pa 
↓ 
pa[0] pa[1] pa[2] …… pa[33] pa[34] 

两维的话就和静态数组有比较大的区别了：（连续性问题请参考上面的汇编分析） 
pb 
↓ 
pb[0] → pb[0][0] pb[0][1] pb[0][2] pb[0][3] pb[0][4] 
pb[1] → pb[1][0] pb[1][1] pb[1][2] pb[1][3] pb[1][4] 
pb[2] → pb[2][0] pb[2][1] pb[2][2] pb[2][3] pb[2][4] 
pb[3] → pb[3][0] pb[3][1] pb[3][2] pb[3][3] pb[3][4] 
pb[4] → pb[4][0] pb[4][1] pb[4][2] pb[4][3] pb[4][4] 
pb[5] → pb[5][0] pb[5][1] pb[5][2] pb[5][3] pb[5][4] 
pb[6] → pb[6][0] pb[6][1] pb[6][2] pb[6][3] pb[6][4] 



数组与指针 
在C/C++中，数组与指针的关系非常密切， 
要清楚理解两者任一个的概念的话，不清楚了解另一个的概念是不可能的。 
所以在这里阐述一下他们的关系。 



从最简单的开始： 
int a[10]; 
int *pa = a; 


声明完这两个变量后，我们可以： 
a[0] = 0; 
同样我们可以： 
*a = 0; // 一次寻址 
*pa = 0; // 两次寻址 
pa[0] = 0; // 两次寻址 

对于*a和*pa来说，其实原型为： 
*(a + 0) 
*(pa + 0) 

因为存在这样一个事实： 
在指针上加上一个值后，并不是单纯在地址上加上该值， 
而是表示一个偏移量，根据类型不同，偏移单位量也是不同的。 

如果以上述例子来说的话，因为int在VC中是4个字节， 
那么每+1，在地址上所加的是sizeof(int)也就是4个字节。 
这样，就和数组的索引值就陪对了起来。即： 
*a 等价于 *(a + 0) 等价于 a[0] 
*(a + 5) 等价于 a[5] 

从另一个方面来说的话，对于 
pa = a; 
也可以写为： 
pa = &a[0]; 
同样，并不一定要指向索引为0的元素， 
pa = a + 7; 
pa = &a[7]; 



接下来考虑稍微复杂一点的静态两维数组： 
int b[7][5]; 
int (*pb)[5] = b; // 声明和赋值写在同一行可能比较混乱，如果单独写的话，应该是 pb = b; 
int (*pb1)[5] = b + 1; // 或者&b[1] 
int *pvalue = (*b) + 1; // 或者&(*b)[1] 
int *pvalue1 = (*pb) + 1; // 或者&(*pb)[1] 


首先解释一下一个常见的问题： 
int **pb = b; 
如果这么写的话，编译器会不客气地扔出一个错误： 
error C2440: '=' : cannot convert from 'int [7][5]' to 'int **' 

猜想的原因可能是因为： 
静态数组和动态数组的结构不同，如果同样采用int** 指针来引用的话， 
在访问具体元素的时候，会产生二义性（指针并不知道引用的数组类型） 

而一旦明确了声明后，对指针的操作时采用两次*取值操作就不会受到太大阻碍。 
以下几种写法都是等价的： 
b[1][1] 
pb1[1][1] 
*(b[1] + 1) 
*(pb1[1] + 1) 
*(*(b + 1) + 1) 
*(*(pb1 + 1) + 1) 

唯一被编译器隐藏的区别就是，与b相关的操作一次寻址，而pb1每次都是两次寻址。 

然后看看那个声明就比较混乱的pb 
在声明中，指明了它是一个指针，指向一个含有5个元素的数组。 
回忆一下第二节.静态两维数组的排列顺序中一句话： 

而对于后者，可以理解为b是一个拥有7个数组类型的数组， 
每个数组类型又是一个拥有5个int类型值的数组。 

两边要表达的意思是一致的，所以，pb的值可以为&b[0] ～ &b[6]中任一个。 

接着我们又声明了一个int指针，用来接具体的值， 
由于pb固定了b的第一维索引值，所以对其解引用（即*操作）， 
操作层从第一维转换到了第二维上，所以我们可以用&(*pb)[1]的形式， 
或者(*pb) + 1的形式来获得某个元素的指针。 


对于动态两维数组，因为其本身声明就是int **pb，所以也不存在什么编译器报错的问题。 
而且对其做两次解引用（*求值操作），也确实根据地址求了两次值。 
如果算上指针本身是地址，需要间接引用的话，所以一共是做了三次间接引用。 



各种数组的声明方式 
对于数组的声明，以及在函数参数中的声明，经常会被编译器拦截， 
被告知声明不符合要求，所以经常会摸不着头脑最后改变数组的形式。 
其实每种声明都可以通过语法实现，只不过因为数组的特殊性， 
所以要说明数组的语法通常都比较复杂一点罢了。 

下表是对各种情况做了一下整理：（假设对函数的调用为func(a)） 
数组声明 说明 函数参数声明 备注 
int a[10]; 一维静态数组 void func(int [10]); 
void func(int []); 
void func(int *); 
数组长度是否明示对函数参数没有影响， 
即使void func(int [100]);这样的声明， 
还是能把a作为参数传入，最多某些严肃的编译器抱怨一个警告而已 

int *pa 一维数组指针 
（静态和动态皆可） 
void func(int [10]); 
void func(int []); 
void func(int *); 
数组指针和一维数组之间的区别很小， 
唯一区别就是，数组作为参数就是把它自己PUSH进栈， 
而指针的话需要间接引用一次，把取得的值PUSH进栈。  
int b[7][5] 两维静态数组 void func(int [7][5]); 
void func(int [][5]); 
void func(int (*)[5]); 
两维静态数组的申明方式基本上和一维的差不了多少， 
但要注意的是必须指定第二维的大小。 
道理很简单，数组在第一维上移动的单位长度必须确定， 
比如a[3] -> a[4]移动的距离必定是sizeof(int [5])。 
所以，也是为什么第二维必须固定，而不是第一维的原因。 

int (*pb)[5] 两维静态数组指针 void func(int [7][5]); 
void func(int [][5]); 
void func(int (*)[5]); 
和一维数组指针基本上一样，区别点也相同。 

int **pb 两维动态数组指针 void func(int **); 
可怜的两维动态数组指针只有一种调用方式:-( 

int c[9][7][5] 三维静态数组 void func(int [9][7][5]); 
void func(int [][7][5]); 
void func(int (*)[7][5]); 
尝试一下声明三维的数组？虽然不常用，呵呵 

int (*pc)[7][5] 三维静态数组指针 void func(int [9][7][5]); 
void func(int [][7][5]); 
void func(int (*)[7][5]); 
别眼花了～ 

int ***pc 三维动态数组指针 void func(int ***); 
三维动态数组指针也好可怜=v= 





静态数组和动态数组在内存的组织方式 

前面也提到过，静态数组在栈内或者在数据段.data内分配空间， 
而动态数组在堆内分配空间。下面从内存角度来说明各自的特点。 



全局变量数组/静态局部变量数组 
这两个数组的生命期都和程序一样长，因为它们的空间是程序运行前就指定完毕的， 
在程序执行过程中，也是通过直接寻址，地址一已经硬编码写在了程序代码中。 

因为运行前就被分配了空间，所以所有元素的初始值被设为0。 

有一种特殊的全局变量数组——字符串 
他们是一种末尾必定以'/0'结尾的特殊的char型数组。 
虽然也属于全局变量数组，但他们被放在了只读的.rdata段中， 
放在只读段中是因为他们是不应该被程序的错误代码而改写的。 
看看下面的例子： 

char* c1 = "abcde"; 
char c2[] = "abcde"; 

c1[0] = 'b'; // 错误 
c2[0] = 'b'; // 正确 

c1是指针，指向一个全局的字符串数组 
c2是一个局部变量数组 
当c1想改写全局字符串数组中某个元素的值的时候， 
会发生Access Violation的异常，因为在该内存区的数据全是只读的。 



局部变量数组 
局部变量数组的空间是从栈上被分配出来的。 
局部变量数组的生命周期只和函数一样长，当然如果声明在某个循环里的时候， 
虽然堆内预留的空间还是存在的，但编译器可能会把这个空间用于其他不和这个变量冲突的变量。 
这样做的目的是为了节省堆栈空间。所以，在循环内的数组变量声明周期也就到循环的结束。 

在栈上分配空间的时候，由于PUSH的效率很低，特别是遇到数组这种大量数据集合的时候， 
所以编译器一般直接通过移动ESP指针来达到分配空间的目的。但编译器做的仅仅是移动指针， 
而分配出来的空间中有些什么垃圾数据，编译器是不会去管的，这个C/C++本身实现目标有关系， 
C/C++是为了性能而设计出来的一种语言。 
它的目标是做最少的事情，用最少的时间完成最多的工作， 
所以，初始化内存的责任就转移到了程序员的身上， 
另外不仅分配内存如此，从很多方面都能感受到C/C++的这个思想。 

栈中的数据不单单有普通变量，数组变量，还有比如返回地址，栈帧，SEH链表，调用参数都在这块空间内。 
其中最重要的是返回地址。 
为什么这么说，首先介绍一个概念——栈溢出。 
栈溢出就是因为不当的操作，把值写到了不应该写的栈地址上面。 
而返回地址决定了程序执行的方向，一旦返回地址被修改，导致程序跳到了其他地方， 
首先是程序出错这是肯定的，此外由于操作系统最终捕获到错误会利用堆栈的返回地址链， 
打印出栈中函数的调用关系，如果返回地址都没有了的话，那就不可能追踪最末层的函数， 
也就会给调试带来的一定的困难。 

说了那么多，其实反过来想说明的问题是，局部变量数组是一个很容易导致堆栈溢出的变量。 
因为数组会有循环迭代，一旦没有控制住，就会越界，越界就有可能发生堆栈溢出。 
关于这点，在下一节杂谈，不为人知的数组表达方式中有简略的实例演示。 



动态数组（数组指针） 
动态数组虽然也有局部的——它的指针， 
但一旦new过了之后，它所指向的实际分配空间是在堆里面的。 

在堆中申请空间有两种方式：C的malloc和C++的new。 
对于基本数据类型的数组来说，这两种申请空间的方式没有什么太大的区别。 

int *pa, *pb; 
pa = (int *)malloc(sizeof(int) * 10); // 正确 
pb = new int[10]; // 正确 

但是，如果类数组的话，一定要用new来分配空间，而不是malloc。 

MyClass *pa, *pb; 
pa = (MyClass *)malloc(sizeof(MyClass) * 10); // 错误 
pb = new MyClass[10]; // 正确 

采用malloc调用的只是分配了一块sizeof(MyClass) * 10大小的空间，其他什么事情都没做。 
采用new调用，不但分配了空间（自动计算），而且还调用了每个MyClass的构造函数。 
对于类来说，构造函数是很重要的，如果没有调用构造函数而使用该类变量的话，可能会出现预想不到的结果。 
同样，在用new []申请空间后，需要用delete []释放空间。 
为什么不是delete，而是delete []？ 
对于基本数据类型的数组来说，delete只释放了pa[0]的空间，而delete []正确地释放了所有的空间。 
对于类的数组来说，delete只调用了pa[0]的析构函数，并是放了空间， 
而delete []调用了所有元素的析构函数，并且正确地释放了所有的空间。 

如果有疑问的话，这样一段小小的程序会告诉你答案的:-) 
代码 输出 

C代码  

1. #include <iostream>  
2. using namespace std;  
3.   
4. class MyClass  
5. {  
6.     public:  
7.         MyClass() {_i = _s_i++; cout << "MyClass(). " << _i << endl;}  
8.         ~MyClass() {cout << "~MyClass(). " << _i << endl;}  
9.     private:  
10.         int _i;  
11.         static int _s_i;  
12. };  
13. int MyClass:: _s_i = 0;  
14.   
15. int main(int argc, char** argv)  
16. {  
17.     MyClass *pa, *pb;  
18.     cout << "[malloc]" << endl;  
19.     pa = (MyClass *)malloc(sizeof(MyClass) * 10);  
20.     cout << "[new]" << endl;  
21.     pb = new MyClass[10];  
22.     delete[] pb;  
23.     pb = 0;  
24.     free(pa);  
25.     pa = 0;  
26. }  
27.   
28.  [malloc]  
29. [new]  
30. MyClass(). 0  
31. MyClass(). 1  
32. MyClass(). 2  
33. MyClass(). 3  
34. MyClass(). 4  
35. MyClass(). 5  
36. MyClass(). 6  
37. MyClass(). 7  
38. MyClass(). 8  
39. MyClass(). 9  
40. ~MyClass(). 9  
41. ~MyClass(). 8  
42. ~MyClass(). 7  
43. ~MyClass(). 6  
44. ~MyClass(). 5  
45. ~MyClass(). 4  
46. ~MyClass(). 3  
47. ~MyClass(). 2  
48. ~MyClass(). 1  
49. ~MyClass(). 0  
50.   
51.    

杂谈，不为人知的数组表达方式 
先看程序=v= 

int i = 4; 
int a[10]; 
int j = 5; 
int b[7][5]; 

0[a] = 6; 
9[a] = 7; 
0[b][0] = 1; 
0[1[b]] = 2; 
0[b[2]] = 3; 

cout << (-1)[a] << endl; 

看完之后，有什么想法么？ 
多数人可能会认为这个东西还是C/C++么？ 
不过很可惜…… 
这段程序在M$的编译器中编译成功。 

为什么这样？！可能有人要疯了。 
慢，其实这个表达方式能够被认可，和第四节数组与指针中的概念有关。 

*a 等价于 *(a + 0) 等价于 a[0] 
*(a + 5) 等价于 a[5] 

有这样一个事实： 
*(a + 0) 和 *(0 + a)要表达的东西是一样的。 
所以可以推导出： 
a[0] 等价于 *(a + 0) 等价于 *(0 + a) 等价于 0[a] 
所以不难可以推导出二维的表达方式： 
b[0][1] = *(b[0] + 1) = *(1 + b[0]) = 1[b[0]] 
b[0][1] = *(b[0] + 1) = *(*(b + 0) + 1) = *(*(0 + b) + 1) = *(0[b] + 1) = 0[b][1] 
b[0][1] = *(b[0] + 1) = *(*(b + 0) + 1) = *(*(0 + b) + 1) = *(1 + *(0 + b)) = *(1 + 0[b]) = 1[0[b]] 

从这个例子可以看出，数组和指针有着非常亲密的关系^^ 


好，让我们喘一口气，怪谈还没完呢～ 
看看最后一个cout输出语句： 
cout << (-1)[a] << endl; 
(-1)[a]根据刚才的知识我们可以得出： (-1)[a] = a[-1] ……等等，-1？编译器怎么没报错？？ 

在C/C++里当然不会报，因为报了就违背C/C++的设计目标了——多管不用管的 
那么再把这个式子转换一下，可以得到*(a - 1) 
按照指针的概念，也就是前一个元素的东西， 
因为a[0]是数组头了，-1会指向哪里呢？猜猜看～ 
或许有人会说是i，因为按照书写的顺序，i在数组a上面。 
但代码书写并非编译器的实现，根据编译器的实现，还有有没有开启优化，结果是不一样的 
按照我目前手头的编译器（见文章的开头），采用DEBUG模式编译出来，输出的结果是5 
也就是指向了j。 


在80x86体系结构，Windows系列操作系统下，栈在内存中从大地址->小地址方向扩展。 
换句话说，栈底在大地址，栈顶在小地址。 
这样，压入参数的时候，i被压在了大地址上，也就是下方， 
然后数组a压在i的上方，因为数组的顺序还是要沿着地址增长的方向扩展 
所以a[0]在上方，a[9]在下方， 
然后j又压在了a[0]的上方，所以a[-1]也就是j了。 


再换句话说，这也就是所谓的栈溢出！ 
列出该程序执行该段程序时，栈的情况的话： 
0012FEE8 j = 5 
0012FEEC a[0] = 6 
0012FEF0 a[1] = ? 
～ 
0012FF0C a[8] = ? 
0012FF10 a[9] = 7 
0012FF14 i = 4 
0012FF18 保存的EBP 
0012FF1C 返回地址 


刚才我们在a[-1]，也就是j，现在我们把矛头转一下，直接对准返回地址。 
按照栈的情况来看，返回地址用数组a来解释就是a[12]，稍微修改一下程序。 
在函数结束前增加一行代码： 
a[12] = 0; 

顺利通过编译，嗯 
执行……！调试器跳出，说有Access Violation 
看一下当前EIP指针，果然等于0 
程序也就这么被栈溢出给抹杀掉了（其实是操作系统抹杀了该程序，栈溢出的行为应该属于借刀杀人=v=） 


不过一般非故意的栈溢出不会这么有针对性，都是循环失控导致的，这样会把栈一路上的地址全部破坏掉。 
所以一般那些检查栈溢出的代码（DEBUG模式下有些编译器会插入），在栈帧两端设防， 
一旦设防标志被破坏就认为发生了栈溢出，所以大多数非故意的栈溢出还是能够通过特定代码监测出来的:-) 



数组的迭代与性能影响 
从简单的角度出发，我们考虑两维静态数组。 
对于数组a[i][j]，采用两层循环来迭代，应该把个索引放外面，哪个索引放里面？ 
如果从理论上来讲，我们知道m固定的情况下，j中的元素是连续的， 
又因为高速缓存读入数据时候按块来读，所以尽量应该使最近访问的数据都在连续的内存上。 
那么我们得出了答案，也就是i放外面，j放里面，写成程序就是： 

#define MAX_I 1024 * 1024 
#define MAX_J 1024 * 512 
int a[MAX_I][MAX_J]; 
for (int i = 0; i < MAX_I; i++) 
    for (int j = 0; j < MAX_J; j++) 
        a[i][j] = 1; 

但理论归理论，还是需要实践才是真理！ 
编写程序，对a[i][j]进行写入测试，测量工具采用CPU指令RDTSC 


RDTSC 
卷绕周期为172年 
精度±0.001微妙（3.4GHz处理器）（受电源管理和乱序执行的影响） 
秒转换：秒数 = 两次测试的差值 / 计算机CPU的频率 


测试程序： 

C代码  

1. #define MAX_I 32 * 512  
2. #define MAX_J 32 * 512  
3. int g_array[MAX_I][MAX_J];  
4.   
5. inline unsigned __int64 GetTick()  
6. {  
7.     __asm RDTSC   
8. }  
9.   
10. int main(int argc, char** argv)  
11. {  
12.     __int64 t1;  
13.   
14.     t1 = GetTick();  
15.     for (int i = 0; i < MAX_I; i++)  
16.         for (int j = 0; j < MAX_J; j++)  
17.             g_array[i][j] = 1;  
18.     cout << GetTick() - t1 << endl;  
19.   
20.     t1 = GetTick();  
21.     for (int j = 0; j < MAX_J; j++)  
22.         for (int i = 0; i < MAX_I; i++)  
23.             g_array[i][j] = 1;  
24.     cout << GetTick() - t1 << endl;  
25. }  

测试用机： 
Intel(R) Core(TM)2 CPU T7400 2.16GHz 2.16GHz 
2.00GB内存 


次数 i外j内 j外i内 
1 3182607649 29253016390 
2 3224917293 27522755221 
3 3160380392 27205374131 
4 3147323816 27746559464 
5 3159460317 27695442775 
6 3150892875 27581611161 
7 3166696546 27459197090 
8 3134793389 27874196311 
9 3161698709 27514023030 
10 3205793422 27283634963 
AVG 3169456440.8 27713581053.6 
毫秒 1467ms 12830ms 


通过测试可见，两种方式导致的性能差别几乎达到了10倍。