woaidongmao

文章均收录自他人博客，但不喜标题前加-[转贴]，因其丑陋，见谅！~
随笔 - 1469, 文章 - 0, 评论 - 661, 引用 - 0
数据加载中……

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

 

http://blog.csdn.net/pony_maggie/article/details/6748662

 

总看到网上一些人说指针访问比数组访问效率高, 但很少人解释其中的原理, 这篇文章从汇编级别上分析一下原因.


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

view plain

  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下的反汇编代码,我加了一些注释方便理解

view plain

  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. } 


 

view plain

  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. } 


 

这是上面代码的反汇编

view plain

  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函数效率要高.

 

posted on 2011-09-07 18:06 肥仔 阅读(1667) 评论(2)  编辑 收藏 引用 所属分类: C++ 基础

评论

# re: 指针访问与数组访问的效率分析  回复  更多评论   

效率高不假 但指针自增自减会带来更多的错误 还有可能覆盖了系统重要内存
2011-11-28 09:30 | jemmyLiu

# re: 指针访问与数组访问的效率分析[未登录]  回复  更多评论   

哟西 。
2013-02-15 21:52 | mengjiangtao

只有注册用户登录后才能发表评论。
网站导航: 博客园   IT新闻   BlogJava   知识库   博问   管理