指针访问与数组访问的效率分析

很多人都知道指针访问比数组访问效率高, 但很少人明白其中的原理, 这篇文章从汇编级别上分析一下原因.

我用一个"reverse"函数来作为例子, 分别用指针和数组的形式来实现这个函数.

[cpp] view plain copy

1. //指针访问  
2. void reverse(char *pStr,int nLen)  
3. {  
4.  char *pStart=pStr;//指向字符串开始  
5.  char *pEnd=pStr+nLen-1;//指向字符串结尾  
6.  char chTmp;  
7.    
8.  while(pEnd > pStart)  
9.  {   
10.   chTmp = *pStart;  
11.   *pStart = *pEnd;  
12.   *pEnd = chTmp;  
13.     
14.   pStart++;  
15.   pEnd--;  
16.  }  
17. }  

上面的函数在vc6下的反汇编代码,我加了一些注释方便理解

[cpp] view plain copy

1. 19:   void reverse(char *pStr,int nLen)  
2. 20:   {  
3. 00401070   push        ebp  
4. 00401071   mov         ebp,esp  
5. 00401073   sub         esp,4Ch  
6. 00401076   push        ebx  
7. 00401077   push        esi  
8. 00401078   push        edi  
9. 00401079   lea         edi,[ebp-4Ch]  
10. 0040107C   mov         ecx,13h  
11. 00401081   mov         eax,0CCCCCCCCh  
12. 00401086   rep stos    dword ptr [edi]//调用子函数时进堆栈保存信息.   
13.   
14. 00401088   mov         eax,dword ptr [ebp+8]  
15. 0040108B   mov         dword ptr [ebp-4],eax//char *pStart=pStr;  
16.   
17. 0040108E   mov         ecx,dword ptr [ebp+0Ch]  
18. 00401091   mov         edx,dword ptr [ebp+8]  
19. 00401094   lea         eax,[edx+ecx-1]  
20. 00401098   mov         dword ptr [ebp-8],eax//char *pEnd=pStr+nLen-1;  
21.      
22. 0040109B   mov         ecx,dword ptr [ebp-8]  
23. 0040109E   cmp         ecx,dword ptr [ebp-4]//while(pEnd > pStart)  
24. 004010A1   jbe         reverse+61h (004010d1)  
25.         
26. 004010A3   mov         edx,dword ptr [ebp-4]//chTmp = *pStart;  
27. 004010A6   mov         al,byte ptr [edx]//取一个字节  
28. 004010A8   mov         byte ptr [ebp-0Ch],al  
29.       
30. 004010AB   mov         ecx,dword ptr [ebp-4]//*pStart = *pEnd;  
31. 004010AE   mov         edx,dword ptr [ebp-8]  
32. 004010B1   mov         al,byte ptr [edx]//从pEnd中取一个字节  
33. 004010B3   mov         byte ptr [ecx],al  
34.           
35. 004010B5   mov         ecx,dword ptr [ebp-8]// *pEnd = chTmp;  
36. 004010B8   mov         dl,byte ptr [ebp-0Ch]  
37. 004010BB   mov         byte ptr [ecx],dl  
38.            
39. 004010BD   mov         eax,dword ptr [ebp-4]//pStart++;  
40. 004010C0   add         eax,1  
41. 004010C3   mov         dword ptr [ebp-4],eax  
42.             
43. 004010C6   mov         ecx,dword ptr [ebp-8]//pEnd--;  
44. 004010C9   sub         ecx,1  
45. 004010CC   mov         dword ptr [ebp-8],ecx  
46. }  

 

[cpp] view plain copy

1. //数组访问  
2. void reverse(char *pStr,int nLen)  
3. {  
4.  int i = 0;  
5.  int j = nLen-1;  
6.  char chTmp;  
7.    
8.  while(j>i)  
9.  {   
10.   chTmp=pStr[i];  
11.   pStr[i]=pStr[j];  
12.   pStr[j]=chTmp;  
13.     
14.   i++;  
15.   j--;      
16.  }  
17. }  

 

这是上面代码的反汇编

[cpp] view plain copy

1. 19:   void reverse(char *pStr,int nLen)  
2. 20:   {  
3. 004010D0   push        ebp  
4. 004010D1   mov         ebp,esp  
5. 004010D3   sub         esp,4Ch  
6. 004010D6   push        ebx  
7. 004010D7   push        esi  
8. 004010D8   push        edi  
9. 004010D9   lea         edi,[ebp-4Ch]  
10. 004010DC   mov         ecx,13h  
11. 004010E1   mov         eax,0CCCCCCCCh  
12. 004010E6   rep stos    dword ptr [edi]  
13.   
14. 004010E8   mov         dword ptr [ebp-4],0  
15.   
16. 004010EF   mov         eax,dword ptr [ebp+0Ch]  
17. 004010F2   sub         eax,1  
18. 004010F5   mov         dword ptr [ebp-8],eax  
19.    
20. 004010F8   mov         ecx,dword ptr [ebp-8]  
21. 004010FB   cmp         ecx,dword ptr [ebp-4]  
22. 004010FE   jle         reverse+6Ah (0040113a)  
23.       
24. 00401100   mov         edx,dword ptr [ebp+8] //注意这里
    
25. 00401103   add         edx,dword ptr [ebp-4]   
26. 00401106   mov         al,byte ptr [edx]  
27. 00401108   mov         byte ptr [ebp-0Ch],al  
28.   
29. 0040110B   mov         ecx,dword ptr [ebp+8]//注意这里
30. 0040110E   add         ecx,dword ptr [ebp-4]   
31. 00401111   mov         edx,dword ptr [ebp+8] //注意这里
32. 00401114   add         edx,dword ptr [ebp-8]   
33. 00401117   mov         al,byte ptr [edx]  
34. 00401119   mov         byte ptr [ecx],al  
35.   
36. 0040111B   mov         ecx,dword ptr [ebp+8] //注意这里
37. 0040111E   add         ecx,dword ptr [ebp-8]   
38. 00401121   mov         dl,byte ptr [ebp-0Ch]  
39. 00401124   mov         byte ptr [ecx],dl  
40.   
41. 00401126   mov         eax,dword ptr [ebp-4]  
42. 00401129   add         eax,1  
43. 0040112C   mov         dword ptr [ebp-4],eax  
44.   
45. 0040112F   mov         ecx,dword ptr [ebp-8]  
46. 00401132   sub         ecx,1  
47. 00401135   mov         dword ptr [ebp-8],ecx  
48. }  

两个函数反汇编后的代码基本是一致的,但第二段汇编中多了几个add语句, 这是因为在用数组下标的形式访问字符串时,总要对数组的首地址做加减操作才能定位到想要的值, 而指针的实现则一开始就copy了一个首地址，不需要再用加减来定位.显然在这个例子中，用指针来实现reverse函数效率要高.

转自：http://blog.csdn.net/pony_maggie/article/details/6748662