C++編譯器到底能幫我們把代碼優化到什麼程度？

TODO: 用while寫法的程式會不會循環展開？

本文位址：

http://blog.csdn.net/hengyunabc/article/details/7170865 一個簡單的累加求和程式：

TYPE S=0;  
	for(int i = 0;i < SIZE; i++) {  
		S += a[i];  
	}           

很多人都覺得這個程式寫得不好，編譯器不能生成很好的彙編代碼。于是有了以下的幾種“優化”：

#include <iostream>
using namespace std;

void main(int argc,char **argv)
{
#define TYPE int
#define SIZE 10000

	TYPE* a=new TYPE[SIZE];  
	for(int i = 0; i<SIZE; ++i){
		a[i] = i;
	}
	//求和，通常版本
	TYPE S=0;  
	for(int i = 0;i < SIZE; i++) {  
		S += a[i];  
	}
	cout<<S<<endl;

	TYPE S2 = 0;
	//版本1：認為中間産生的變量i是多餘的，改為用移動指針
	TYPE* end = a + SIZE;
	for( ; a != end; ) {  
		S2 += *(a++);  
	}
	cout<<S2<<endl;

	//版本1中把a移到了數組的最後，現在移回原來的位置
	a = end - SIZE;

	//版本2：認為循環次數太多了，可以改為減少循環次數
	TYPE S3 = 0;
	for(int i = 0; i < SIZE; ){ //僅當SIZE為偶數時
		S3 += a[i++];
		S3 += a[i++];
	}
	cout<<S3<<endl;

	//版本3：認為版本2中會使CPU不能亂序執行，降低了效率，應該改為彙編，把中間結果放到獨立的寄存器中
	//謝謝 menzi11 的文章，讓我認識到程式中相關的資料會讓CPU不能亂序執行。
	//這裡用僞彙編代替
	TYPE S4 = 0;

	register TYPE r1 = 0;
	register TYPE r2 = 0;
	for(int i = 0; i < SIZE; ){ //僅當SIZE為偶數時
		r1 += a[i++];
		r2 += a[i++];
	}

	cout<<r1 + r2<<endl;
}           

上面的幾種版本都合理，但是這些優化都是建立在編譯器不能生成高效的彙編代碼的假設上的。

下面來看下編譯器生成的結果（vs2010，release)：

for(int i = 0;i < SIZE; i++) {  
		S += a[i];  
013B1040  mov         ebx,dword ptr [eax+4]  //把a[0],a[4],a[8]...累加到ebx中
013B1043  add         ecx,dword ptr [eax-8]  //把a[1],a[5],a[9]...累加到ecx中
013B1046  add         edx,dword ptr [eax-4]  //把a[2],a[6],a[10]...累加到edx中
013B1049  add         esi,dword ptr [eax]    //把a[3],a[7],a[11]...累加到esi中
013B104B  add         dword ptr [ebp-4],ebx  
013B104E  add         eax,10h  
013B1051  dec         dword ptr [ebp-8]  
013B1054  jne         main+40h (13B1040h)  
	}
	cout<<S<<endl;
013B1056  mov         eax,dword ptr [ebp-4]  
013B1059  add         eax,esi  		      
013B105B  add         eax,edx  
013B105D  mov         edx,dword ptr [__imp_std::endl (13B204Ch)]  
013B1063  add         ecx,eax                //上面的3條add指令把ebx，ecx，edx，edi都加到ecx中，即ecx是累加結果           

可見編譯器生成的代碼是最好的代碼，消滅了中間變量i，減少了循環次數，消滅了會造成CPU不能亂序執行的因素。

BTW：

有人可能會有疑問：要是size不是偶數，編譯器能生成類似的高效彙編代碼不？

當SIZE = 9999時：

//當SIZE = 9999時，編譯器把中間結果放到三個寄存器中，perfect
	for(int i = 0;i < SIZE; i++) {  
		S += a[i];  
01341030  add         ecx,dword ptr [eax-8]  
01341033  add         edx,dword ptr [eax-4]  
01341036  add         esi,dword ptr [eax]  
01341038  add         eax,0Ch  
0134103B  dec         ebx  
0134103C  jne         main+30h (1341030h)  
	}           

當SIZE  = 9997 時：

//當SIZE = 9997時，有點複雜，先把a[0]到a[9995]累加到ecx和edx中
//再把a[9996]入到edi中，最後把ecx，edi都加到edx中
//edx壓棧，調用operator<< 函數
	for(int i = 0;i < SIZE; i++) {  
00D31024  xor         eax,eax  
		S += a[i];  
00D31026  add         ecx,dword ptr [esi+eax*4]  
00D31029  add         edx,dword ptr [esi+eax*4+4]  
00D3102D  add         eax,2  
00D31030  cmp         eax,270Ch  
00D31035  jl          main+26h (0D31026h)  
	for(int i = 0;i < SIZE; i++) {  
00D31037  cmp         eax,270Dh  
00D3103C  jge         main+41h (0D31041h)  
		S += a[i];  
00D3103E  mov         edi,dword ptr [esi+eax*4]  
	}
	cout<<S<<endl;
00D31041  mov         eax,dword ptr [__imp_std::endl (0D3204Ch)]  
00D31046  add         edx,ecx  
00D31048  mov         ecx,dword ptr [__imp_std::cout (0D32050h)]  
00D3104E  push        eax  
00D3104F  add         edx,edi  
00D31051  push        edx  
00D31052  call        dword ptr [__imp_std::basic_ostream<char,std::char_traits<char> >::operator<< (0D32048h)]             

上面的分析都是SIZE，即數組的大小是已知情況下，那個數組大小是未知情況下，編譯器又會怎樣？

TYPE mySum(TYPE* a, int size){
	TYPE s = 0;
	for(int i = 0; i < size; ++i){
		s += a[i];
	}
	return s;
}           

生成的彙編代碼：

//先累加a[0] 到 a[size-2]
	TYPE s = 0;
00ED100C  xor         esi,esi  
	for(int i = 0; i < size; ++i){
00ED100E  xor         eax,eax  
00ED1010  cmp         ebx,2  
00ED1013  jl          mySum+27h (0ED1027h)  
00ED1015  dec         ebx  
		s += a[i];
00ED1016  add         ecx,dword ptr [edi+eax*4]    //a[0],a[2],a[4]...加到ecx中
00ED1019  add         edx,dword ptr [edi+eax*4+4]  //a[1],a[3],a[5]...加到edx中
00ED101D  add         eax,2  
00ED1020  cmp         eax,ebx  
00ED1022  jl          mySum+16h (0ED1016h)  
00ED1024  mov         ebx,dword ptr [size]  
	for(int i = 0; i < size; ++i){
00ED1027  cmp         eax,ebx                       //判斷最後一個元素有沒有加上
00ED1029  jge         mySum+2Eh (0ED102Eh)  
		s += a[i];
00ED102B  mov         esi,dword ptr [edi+eax*4]     //當size是奇數是會執行，偶數時不會執行
00ED102E  add         edx,ecx  
	}           

總結：C++的編譯器生成的彙編代碼在絕大多數情況下都和人寫出的最好的彙編代碼相當。

關鍵的一點是編譯器會不斷更新，适應新的cpu指令，體系等，手寫的彙編代碼則通常悲劇了。

知道編譯器能優化到什麼程度，編譯器到底怎樣優化，是程式員很重要的素質。