• <ins id="pjuwb"></ins>
    <blockquote id="pjuwb"><pre id="pjuwb"></pre></blockquote>

    <noscript id="pjuwb"></noscript>
          <sup id="pjuwb"><pre id="pjuwb"></pre></sup>

            <dd id="pjuwb"></dd>
            <abbr id="pjuwb"></abbr>
            

    
            

            




            







												


        

            
	
            
		
			

            

            
	
            
		
			
            woaidongmao
            
			文章均收錄自他人博客，但不喜標題前加-[轉貼]，因其丑陋，見諒！~
		            		
	
            

            

            

            

            隨筆 - 1469, 文章 - 0, 評論 - 661, 引用 - 0
            

            


            		
	
            

            

            
	
            
		
			
            
				數據加載中……
			
            
		            		
		
			
            
				
					
	
            
		
            
			指針訪問與數組訪問的效率分析
		
            
		
            
		
             
             
            http://blog.csdn.net/pony_maggie/article/details/6748662
             
             
             
            總看到網上一些人說指針訪問比數組訪問效率高, 但很少人解釋其中的原理, 這篇文章從匯編級別上分析一下原因.
             

            我用一個"reverse"函數來作為例子, 分別用指針和數組的形式來實現這個函數.
             
            view plain
             
             
               
            1. //指針訪問  
              2.  
            2. void reverse(char *pStr,int nLen)  
              3.  
            3. {  
              4.  
            4.  char *pStart=pStr;//指向字符串開始  
              5.  
            5.  char *pEnd=pStr+nLen-1;//指向字符串結尾  
              6.  
            6.  char chTmp;  
              7.  
            7.    
              8.  
            8.  while(pEnd > pStart)  
              9.  
            9.  {   
              10.  
            10.   chTmp = *pStart;  
              11.  
            11.   *pStart = *pEnd;  
              12.  
            12.   *pEnd = chTmp;  
              13.  
            13.     
              14.  
            14.   pStart++;  
              15.  
            15.   pEnd--;  
              16.  
            16.  }  
              17.  
            17. }  
             


            這是上面的函數在vc6下的反匯編代碼,我加了一些注釋方便理解
             
            view plain
             
             
               
            1. 19:   void reverse(char *pStr,int nLen)  
              2.  
            2. 20:   {  
              3.  
            3. 00401070   push        ebp  
              4.  
            4. 00401071   mov         ebp,esp  
              5.  
            5. 00401073   sub         esp,4Ch  
              6.  
            6. 00401076   push        ebx  
              7.  
            7. 00401077   push        esi  
              8.  
            8. 00401078   push        edi  
              9.  
            9. 00401079   lea         edi,[ebp-4Ch]  
              10.  
            10. 0040107C   mov         ecx,13h  
              11.  
            11. 00401081   mov         eax,0CCCCCCCCh  
              12.  
            12. 00401086   rep stos    dword ptr [edi]//調用子函數時進堆棧保存信息.   
              13.  
            13.   
              14.  
            14. 00401088   mov         eax,dword ptr [ebp+8]  
              15.  
            15. 0040108B   mov         dword ptr [ebp-4],eax//char *pStart=pStr;  
              16.  
            16.   
              17.  
            17. 0040108E   mov         ecx,dword ptr [ebp+0Ch]  
              18.  
            18. 00401091   mov         edx,dword ptr [ebp+8]  
              19.  
            19. 00401094   lea         eax,[edx+ecx-1]  
              20.  
            20. 00401098   mov         dword ptr [ebp-8],eax//char *pEnd=pStr+nLen-1;  
              21.  
            21.      
              22.  
            22. 0040109B   mov         ecx,dword ptr [ebp-8]  
              23.  
            23. 0040109E   cmp         ecx,dword ptr [ebp-4]//while(pEnd > pStart)  
              24.  
            24. 004010A1   jbe         reverse+61h (004010d1)  
              25.  
            25.         
              26.  
            26. 004010A3   mov         edx,dword ptr [ebp-4]//chTmp = *pStart;  
              27.  
            27. 004010A6   mov         al,byte ptr [edx]//取一個字節  
              28.  
            28. 004010A8   mov         byte ptr [ebp-0Ch],al  
              29.  
            29.       
              30.  
            30. 004010AB   mov         ecx,dword ptr [ebp-4]//*pStart = *pEnd;  
              31.  
            31. 004010AE   mov         edx,dword ptr [ebp-8]  
              32.  
            32. 004010B1   mov         al,byte ptr [edx]//從pEnd中取一個字節  
              33.  
            33. 004010B3   mov         byte ptr [ecx],al  
              34.  
            34.           
              35.  
            35. 004010B5   mov         ecx,dword ptr [ebp-8]// *pEnd = chTmp;  
              36.  
            36. 004010B8   mov         dl,byte ptr [ebp-0Ch]  
              37.  
            37. 004010BB   mov         byte ptr [ecx],dl  
              38.  
            38.            
              39.  
            39. 004010BD   mov         eax,dword ptr [ebp-4]//pStart++;  
              40.  
            40. 004010C0   add         eax,1  
              41.  
            41. 004010C3   mov         dword ptr [ebp-4],eax  
              42.  
            42.             
              43.  
            43. 004010C6   mov         ecx,dword ptr [ebp-8]//pEnd--;  
              44.  
            44. 004010C9   sub         ecx,1  
              45.  
            45. 004010CC   mov         dword ptr [ebp-8],ecx  
              46.  
            46. }  
             

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

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

            兩個函數反匯編后的代碼基本是一致的,但第二段匯編中多了幾個add語句, 這是因為在用數組下標的形式訪問字符串時,總要對數組的首地址做加減操作才能定位到想要的值, 而指針的實現則一開始就copy了一個首地址，不需要再用加減來定位.顯然在這個例子中，用指針來實現reverse函數效率要高. 
             
             
            
		
            
		
            
			posted on 2011-09-07 18:06 肥仔 閱讀(1682) 評論(2)  編輯 收藏 引用  所屬分類: C++ 基礎 
		
            
	
            
	
	


	


            
	    
    


            

            評論
            
	
	
			
            
				
            
					# re: 指針訪問與數組訪問的效率分析  回復  更多評論
					  
				
            
				效率高不假   但指針自增自減會帶來更多的錯誤   還有可能覆蓋了系統重要內存
				
            
					2011-11-28 09:30 | jemmyLiu
				
            
			
            
		
			
            
				
            
					# re: 指針訪問與數組訪問的效率分析[未登錄]  回復  更多評論
					  
				
            
				喲西 。
				
            
					2013-02-15 21:52 | mengjiangtao
				
            
			
            
		

            





            






            

				
			
            
		            		
	
            
	
            
		
			

		
	
            

            

    
    







            
	   
	



精品无码久久久久国产|
99久久无码一区人妻a黑|
久久97精品久久久久久久不卡
|
午夜精品久久久久久|
久久精品国产秦先生|
久久精品人人做人人爽电影蜜月|
久久天天躁狠狠躁夜夜2020一
|
亚洲中文字幕伊人久久无码|
精品久久久久久久久久中文字幕|
欧美久久精品一级c片片|
91视频国产91久久久|
www.久久热.com|
国产91色综合久久免费|
久久精品国产99国产精品澳门
|
久久国产精品波多野结衣AV|
高清免费久久午夜精品|
亚洲一本综合久久|
久久精品国产精品亚洲人人|
久久精品女人天堂AV麻|
一本色综合久久|
亚洲午夜久久久影院|
2020久久精品国产免费|
中文字幕亚洲综合久久2|
国产亚州精品女人久久久久久
|
久久精品国产亚洲AV不卡|
久久中文字幕无码专区|
亚洲综合久久久|
久久人人爽人人爽人人AV|
777米奇久久最新地址|
婷婷综合久久狠狠色99h|
久久久WWW成人|
亚洲AV无码1区2区久久|
久久精品国产只有精品2020|
精品无码人妻久久久久久|
久久大香萑太香蕉av|
九九久久自然熟的香蕉图片|
久久国产精品99久久久久久老狼|
国产激情久久久久影院老熟女免费
|
久久国产精品国语对白|
久久精品国产国产精品四凭
|
青春久久|