• <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久久久香蕉|
热RE99久久精品国产66热|
久久久久高潮综合影院|
国产成人精品免费久久久久|
国产69精品久久久久9999|
色狠狠久久综合网|
无码人妻久久一区二区三区免费|
久久噜噜电影你懂的|
女人高潮久久久叫人喷水|
99久久人妻无码精品系列|
久久久久女教师免费一区|
亚洲AV无码久久|
91久久九九无码成人网站|
奇米影视7777久久精品人人爽|
999久久久免费精品国产|
亚洲精品tv久久久久|
人妻少妇久久中文字幕|
精品无码人妻久久久久久|
无码伊人66久久大杳蕉网站谷歌|
欧美精品一区二区精品久久|
国产精品99久久久久久宅男小说|
久久精品国产亚洲AV大全|
人妻中文久久久久|
一本大道久久a久久精品综合|
三级三级久久三级久久|
久久强奷乱码老熟女|
国产亚洲精品自在久久|
亚洲精品乱码久久久久久蜜桃不卡|
亚洲国产精品久久久久网站
|
无码人妻久久一区二区三区|
久久精品人妻一区二区三区|
国产精品视频久久久|
五月丁香综合激情六月久久|
一本久久a久久精品综合香蕉|
久久av免费天堂小草播放|
久久精品国产精品青草|
国产精品对白刺激久久久|
久久偷看各类wc女厕嘘嘘|