一个简单的累加求和程序：
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++) {
03. S += a[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]
17. }
18. cout<<S<<endl;
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]
02. TYPE s = 0;
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指令，体系等，手写的汇编代码则通常悲剧了。
知道编译器能优化到什么程度，编译器到底怎样优化，是程序员很重要的素质。
