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

一個簡單的累加求和程式：

01.TYPE S=0;

02.for(int i = 0;i < SIZE; i++) {

03. S += a[i];

04.}

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

01.#include

02.using namespace std;

03.

04.void main(int argc,char **argv)

05.{

06.#define TYPE int

07.#define SIZE 10000

08.

09. TYPE* a=new TYPE[SIZE];

10. for(int i = 0; i<SIZE; ++i){

11. a[i] = i;

12. }

13. //求和，通常版本

14. TYPE S=0;

15. for(int i = 0;i < SIZE; i++) {

16. S += a[i];

17. }

18. cout<<S<<endl;

19.

20. TYPE S2 = 0;

21. //版本1：認為中間産生的變量i是多餘的，改為用移動指針

22. TYPE* end = a + SIZE;

23. for( ; a != end; ) {

24. S2 += *(a++);

25. }

26. cout<<S2<<endl;

27.

28. //版本1中把a移到了數組的最後，現在移回原來的位置

29. a = end - SIZE;

30.

31. //版本2：認為循環次數太多了，可以改為減少循環次數

32. TYPE S3 = 0;

33. for(int i = 0; i < SIZE; ){ //僅當SIZE為偶數時

34. S3 += a[i++];

35. S3 += a[i++];

36. }

37. cout<<S3<<endl;

38.

39. //版本3：認為版本2中會使CPU不能亂序執行，降低了效率，應該改為彙編，把中間結果放到獨立的寄存器中

40. //謝謝 menzi11 的文章，讓我認識到程式中相關的資料會讓CPU不能亂序執行。

41. //這裡用僞彙編代替

42. TYPE S4 = 0;

43.

44. register TYPE r1 = 0;

45. register TYPE r2 = 0;

46. for(int i = 0; i < SIZE; ){ //僅當SIZE為偶數時

47. r1 += a[i++];

48. r2 += a[i++];

49. }

50.

51. cout<<r1 + r2<<endl;

52.}

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

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

01. for(int i = 0;i < SIZE; i++) {

02. S += a[i];

03.013B1040 mov ebx,dword ptr [eax+4] //把a[0],a[4],a[8]...累加到ebx中

04.013B1043 add ecx,dword ptr [eax-8] //把a[1],a[5],a[9]...累加到ecx中

05.013B1046 add edx,dword ptr [eax-4] //把a[2],a[6],a[10]...累加到edx中

06.013B1049 add esi,dword ptr [eax] //把a[3],a[7],a[11]...累加到esi中

07.013B104B add dword ptr [ebp-4],ebx

08.013B104E add eax,10h

09.013B1051 dec dword ptr [ebp-8]

10.013B1054 jne main+40h (13B1040h)

11. }

12. cout<<S<<endl;

13.013B1056 mov eax,dword ptr [ebp-4]

14.013B1059 add eax,esi

15.013B105B add eax,edx

16.013B105D mov edx,dword ptr [__imp_std::endl (13B204Ch)]

17.013B1063 add ecx,eax //上面的3條add指令把ebx，ecx，edx，edi都加到ecx中，即ecx是累加結果

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

BTW：

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

當SIZE = 9999時：

01.//當SIZE = 9999時，編譯器把中間結果放到三個寄存器中，perfect

02. for(int i = 0;i < SIZE; i++) {

04.01341030 add ecx,dword ptr [eax-8]

05.01341033 add edx,dword ptr [eax-4]

06.01341036 add esi,dword ptr [eax]

07.01341038 add eax,0Ch

08.0134103B dec ebx

09.0134103C jne main+30h (1341030h)

10. }

當SIZE = 9997 時：

01.//當SIZE = 9997時，有點複雜，先把a[0]到a[9995]累加到ecx和edx中

02.//再把a[9996]入到edi中，最後把ecx，edi都加到edx中

03.//edx壓棧，調用operator<< 函數

04. for(int i = 0;i < SIZE; i++) {

05.00D31024 xor eax,eax

06. S += a[i];

07.00D31026 add ecx,dword ptr [esi+eax*4]

08.00D31029 add edx,dword ptr [esi+eax*4+4]

09.00D3102D add eax,2

10.00D31030 cmp eax,270Ch

11.00D31035 jl main+26h (0D31026h)

12. for(int i = 0;i < SIZE; i++) {

13.00D31037 cmp eax,270Dh

14.00D3103C jge main+41h (0D31041h)

15. S += a[i];

16.00D3103E mov edi,dword ptr [esi+eax*4]

19.00D31041 mov eax,dword ptr [__imp_std::endl (0D3204Ch)]

20.00D31046 add edx,ecx

21.00D31048 mov ecx,dword ptr [__imp_std::cout (0D32050h)]

22.00D3104E push eax

23.00D3104F add edx,edi

24.00D31051 push edx

25.00D31052 call dword ptr [__imp_std::basic_ostream<char,std::char_traits >::operator<< (0D32048h)]

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

01.TYPE mySum(TYPE* a, int size){

02. TYPE s = 0;

03. for(int i = 0; i < size; ++i){

04. s += a[i];

05. }

06. return s;

07.}

生成的彙編代碼：

01.//先累加a[0] 到 a[size-2]

03.00ED100C xor esi,esi

04. for(int i = 0; i < size; ++i){

05.00ED100E xor eax,eax

06.00ED1010 cmp ebx,2

07.00ED1013 jl mySum+27h (0ED1027h)

08.00ED1015 dec ebx

09. s += a[i];

10.00ED1016 add ecx,dword ptr [edi+eax*4] //a[0],a[2],a[4]...加到ecx中

11.00ED1019 add edx,dword ptr [edi+eax*4+4] //a[1],a[3],a[5]...加到edx中

12.00ED101D add eax,2

13.00ED1020 cmp eax,ebx

14.00ED1022 jl mySum+16h (0ED1016h)

15.00ED1024 mov ebx,dword ptr [size]

16. for(int i = 0; i < size; ++i){

17.00ED1027 cmp eax,ebx //判斷最後一個元素有沒有加上

18.00ED1029 jge mySum+2Eh (0ED102Eh)

19. s += a[i];

20.00ED102B mov esi,dword ptr [edi+eax*4] //當size是奇數是會執行，偶數時不會執行

21.00ED102E add edx,ecx

22. }

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

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

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