C++反汇编
Microsoft Visual C++ 6.0在使用浮点数前，需要先对浮点寄存器进行初始化，然后才能使用
程序崩溃的原因：在浮点寄存器没有初始化时使用浮点操作，将无法转换小数部分
在代码中任意一个位置（用之前）定义一个浮点类型变量即可对浮点寄存器初始化
在C++中，引用和指针没有什么区别。只是引用是通过编译器实现寻址，而指针需要手动寻址。指针虽然灵活，但操作失误将产生严重的后果，而使用引用则不存在这种问题
mainCRTStartup函数：
1 #ifdef WPRFLAG
2 void wmainCRTStartup(
3 #else /* WPRFLAG */
4 void mainCRTStartup(
5 #endif /* WPRFLAG */
6
7 #endif /* _WINMAIN_ */
8 void
9 )
10
11 {
12 int mainret;
13
14 #ifdef _WINMAIN_
15 _TUCHAR *lpszCommandLine;
16 STARTUPINFO StartupInfo;
17 #endif /* _WINMAIN_ */
18
19 /*
20 * Get the full Win32 version
21 */
22 _osver = GetVersion();
23
24 _winminor = (_osver >> 8) & 0x00FF ;
25 _winmajor = _osver & 0x00FF ;
26 _winver = (_winmajor << 8) + _winminor;
27 _osver = (_osver >> 16) & 0x00FFFF ;
28
29 #ifdef _MT
30 if ( !_heap_init(1) ) /* initialize heap */
31 #else /* _MT */
32 if ( !_heap_init(0) ) /* initialize heap */
33 #endif /* _MT */
34 fast_error_exit(_RT_HEAPINIT); /* write message and die */
35
36 #ifdef _MT
37 if( !_mtinit() ) /* initialize multi-thread */
38 fast_error_exit(_RT_THREAD); /* write message and die */
39 #endif /* _MT */
40
41 /*
42 * Guard the remainder of the initialization code and the call
43 * to user's main, or WinMain, function in a __try/__except
44 * statement.
45 */
46
47 __try {
48
49 _ioinit(); /* initialize lowio */
50
51 #ifdef WPRFLAG
52 /* get wide cmd line info */
53 _wcmdln = (wchar_t *)__crtGetCommandLineW();
54
55 /* get wide environ info */
56 _wenvptr = (wchar_t *)__crtGetEnvironmentStringsW();
57
58 _wsetargv();
59 _wsetenvp();
60 #else /* WPRFLAG */
61 /* get cmd line info */
62 _acmdln = (char *)GetCommandLineA();
63
64 /* get environ info */
65 _aenvptr = (char *)__crtGetEnvironmentStringsA();
66
67 _setargv();
68 _setenvp();
69 #endif /* WPRFLAG */
70
71 _cinit(); /* do C data initialize */
72
73 #ifdef _WINMAIN_
74
75 StartupInfo.dwFlags = 0;
76 GetStartupInfo( &StartupInfo );
77
78 #ifdef WPRFLAG
79 lpszCommandLine = _wwincmdln();
80 mainret = wWinMain(
81 #else /* WPRFLAG */
82 lpszCommandLine = _wincmdln();
83 mainret = WinMain(
84 #endif /* WPRFLAG */
85 GetModuleHandleA(NULL),
86 NULL,
87 lpszCommandLine,
88 StartupInfo.dwFlags & STARTF_USESHOWWINDOW
89 ? StartupInfo.wShowWindow
90 : SW_SHOWDEFAULT
91 );
92 #else /* _WINMAIN_ */
93
94 #ifdef WPRFLAG
95 __winitenv = _wenviron;
96 mainret = wmain(__argc, __wargv, _wenviron);
97 #else /* WPRFLAG */
98 __initenv = _environ;
99 mainret = main(__argc, __argv, _environ);
100 #endif /* WPRFLAG */
101
102 #endif /* _WINMAIN_ */
103 exit(mainret);
104 }
105 __except ( _XcptFilter(GetExceptionCode(), GetExceptionInformation()) )
106 {
107 /*
108 * Should never reach here
109 */
110 _exit( GetExceptionCode() );
111
112 } /* end of try - except */
113
114 }
在VC++ 6.0中main函数被调用前要先调用函数如下：
1,GetVersion（）
2,_heap_init()
3,GetCommandLineA();
4,_crtGetEnvironmentStringsA()
5,_setargv()
6,_setenvp()
7,_cinit()
这些函数调用结束后就会调用main函数：
VC++6.0中，算数运算与其他传递计算结果的代码组合才能被视为一条有效的语句。
单独的算术运算虽然可以编译通过，但是并不会生成代码。
因为只进行计算而没有传递结果的运算不会对程序结果有任何影响，此时编译器将其视为无效语句：
VC++6.0中常用的优化方案有两种：
O1方案：生成文件占用空间最小
O2方案：执行效率最快
Release 使用的是O2方案
Debug 使用的是Od+ZI选项，加有调试内容
->Debug版反汇编：
1 1: #include <stdio.h>
2 2:
3 3: int main()
4 4: {
5 0040D400 push ebp
6 0040D401 mov ebp,esp
7 0040D403 sub esp,48h
8 0040D406 push ebx
9 0040D407 push esi
10 0040D408 push edi
11 0040D409 lea edi,[ebp-48h]
12 0040D40C mov ecx,12h
13 0040D411 mov eax,0CCCCCCCCh
14 0040D416 rep stos dword ptr [edi]
15 5: 15 + 20; //无效语句
16 6:
17 7: int nVarOne = 0 ;
18 0040D418 mov dword ptr [ebp-4],0 ；将立即数0传入到地址ebp-4中，即变量nVarOne所在的地址
19 8: int nVarTwo = 0 ;
20 0040D41F mov dword ptr [ebp-8],0 ；将立即数0传入到地址ebp-8中，即变量nVarTwo所在的地址
21 9:
22 10: nVarOne = nVarOne + 1;
23 0040D426 mov eax,dword ptr [ebp-4] ；取出nVarOne，放入eax寄存器中
24 0040D429 add eax,1 ；把eax中数据（nVarOne）加1
25 0040D42C mov dword ptr [ebp-4],eax ；把eax中的值放回ebp-4地址处
26 11:
27 12:
28 13: nVarOne = 1 + 2;
29 0040D42F mov dword ptr [ebp-4],3 ；把3放入ebp-4的地址处，即nVarOne所在地址
30 14:
31 15: nVarOne = nVarOne + nVarTwo;
32 0040D436 mov ecx,dword ptr [ebp-4] ；把nVarOne取出，放在寄存器ecx中
33 0040D439 add ecx,dword ptr [ebp-8] ；ecx中的值（nVarOne） 加上 ebp-8 中的值（nVarTwo），结果放在ecx中
34 0040D43C mov dword ptr [ebp-4],ecx ；把加后的ecx的值放回ebp-4地址处，即nVarone地址处
35 16:
36 17: printf("nVarOnw = %d \r\n",nVarOne);
37 0040D43F mov edx,dword ptr [ebp-4] ；把nVarOne放入edx中
38 0040D442 push edx ；把edx入栈
39 0040D443 push offset string "nVarOnw = %d \r\n" (00422e80) ；把格式控制字符串入栈
40 0040D448 call printf (0040d6d0) ；调用printf函数
41 0040D44D add esp,8 ；主调函数修复栈
42 18:
43 19: return 0;
44 0040D450 xor eax,eax ；清零eax
45 20: }
46 0040D452 pop edi ；edi出栈
47 0040D453 pop esi ；esi出栈
48 0040D454 pop ebx ；ebx出栈
49 0040D455 add esp,48h ；main函数修复栈
50 0040D458 cmp ebp,esp ；比较ebp和esp
51 0040D45A call __chkesp (0040d690) ；调用__chkesp检查调整栈
52 0040D45F mov esp,ebp ；恢复esp栈
53 0040D461 pop ebp ；ebp出栈
54 0040D462 ret ；返回
->Release版反汇编：
1 ;int __cdecl main(int argc,const char **argv,const char **envp)
2 _main proc near
3 push 3
4 push offset Format ; "nVarOne = %d \r\n"
5 call _printf
6 add esp,8
7 xor eax,eax
8 retn
9 _main endp
在编译过程中，编译器常常会采用“常量传播”和“常量折叠”这样的方案对代码中的变量和常量进行优化：
>常量传播：将编译期间可计算 出结果的变量转化为常量，这样就减少了变量的使用
例如，这样一段代码：
1 #include <stdio.h>
2
3 int main()
4 {
5 int nVar = 1;
6 printf("nVar = %d \r\n",nVar);
7 return 0;
8 }
被优化后为：
1 #include <stdio.h>
2
3 int main()
4 {
5 printf("nVar = %d \r\n",1);
6 return 0;
7 }
>常量折叠：当计算公式中出现多个常量进行计算的情况时，且编译器可以在编译期间计算出结果时，这样所有常量计算都被计算结果代替：
这样一段代码：
1 #include <stdio.h>
2
3 int main()
4 {
5 int nVar = 1 + 5 - 3 * 6;
6 printf("nVar = %d \r\n",nVar);
7 return 0;
8 }
常量折叠后：
1 #include <stdio.h>
2
3 int main()
4 {
5 int nVar = -12;
6 printf("nVar = %d \r\n",nVar);
7 return 0;
8 }
再经常量传播后：
1 #include <stdio.h>
2
3 int main()
4 {
5 printf("nVar = %d \r\n",-12);
6 return 0;
7 }
如果开启O2优化方案后，变量在程序的逻辑中，声明的变量没有被修改过，而且上下文中不存在针对变量取地址和间接访问的操作，那么这个变量就等价于常量
编译器就认为可以删除这个变量，直接用常量代替
看下面另一个例子：
源代码：
1 #include <stdio.h>
2
3 int main(int argc,char *argv[])
4 {
5 int nVarOne = argc;
6 int nVarTwo = argc;
7
8 nVarOne = nVarOne + 1;
9 nVarOne = 1 + 2;
10 nVarOne = nVarOne + nVarTwo;
11
12 printf("nVarOne = %d \r\n",nVarOne);
13
14 return 0;
15 }
优化后源代码可能为：
1 #include <stdio.h>
2
3 int main(int argc,char *argv[])
4 {
5 printf("nVarOne = %d \r\n",3 + argc);
6 return 0;
7 }
汇编代码：Debug版
1 1: #include <stdio.h>
2 2:
3 3: int main(int argc,char *argv[])
4 4: {
5 0040D400 push ebp
6 0040D401 mov ebp,esp
7 0040D403 sub esp,48h
8 0040D406 push ebx
9 0040D407 push esi
10 0040D408 push edi
11 0040D409 lea edi,[ebp-48h]
12 0040D40C mov ecx,12h
13 0040D411 mov eax,0CCCCCCCCh
14 0040D416 rep stos dword ptr [edi]
15 5: int nVarOne = argc;
16 0040D418 mov eax,dword ptr [ebp+8]
17 0040D41B mov dword ptr [ebp-4],eax
18 6: int nVarTwo = argc;
19 0040D41E mov ecx,dword ptr [ebp+8]
20 0040D421 mov dword ptr [ebp-8],ecx
21 7:
22 8: nVarOne = nVarOne + 1;
23 0040D424 mov edx,dword ptr [ebp-4]
24 0040D427 add edx,1
25 0040D42A mov dword ptr [ebp-4],edx
26 9: nVarOne = 1 + 2;
27 0040D42D mov dword ptr [ebp-4],3
28 10: nVarOne = nVarOne + nVarTwo;
29 0040D434 mov eax,dword ptr [ebp-4]
30 0040D437 add eax,dword ptr [ebp-8]
31 0040D43A mov dword ptr [ebp-4],eax
32 11:
33 12: printf("nVarOne = %d \r\n",nVarOne);
34 0040D43D mov ecx,dword ptr [ebp-4]
35 0040D440 push ecx
36 0040D441 push offset string "nVarOne = %d \r\n" (00422e80)
37 0040D446 call printf (0040d6d0)
38 0040D44B add esp,8
39 13:
40 14: return 0;
41 0040D44E xor eax,eax
42 15: }
43 0040D450 pop edi
44 0040D451 pop esi
45 0040D452 pop ebx
46 0040D453 add esp,48h
47 0040D456 cmp ebp,esp
48 0040D458 call __chkesp (0040d690)
49 0040D45D mov esp,ebp
50 0040D45F pop ebp
51 0040D460 ret
汇编代码：Release版
1 ;int __cdecl main(int argc,const char **argv,const char **envp)
2 _main proc near
3
4 arg_0= dword ptr 4
5
6 mov eax,[esp+arg_0]
7 add eax,3
8 push eax
9 push offset Format ; "nVarOne = %d \r\n"
10 call _printf
11 add esp,8
12 xor eax,eax
13 retn
14 _main endp
虽然计算机只会做加法，但是可以通过补码转换将减法转变为加法形式来完成
设有二进制Y,其反码记为Y(反),假定其二进制长度为8位：
Y + Y(反) = 1111 1111B
Y + Y(反) + 1 = 0 (进位丢失)
Y(反) + 1 = 0 - Y <==> Y(反) + 1 = -Y <==> Y(补) = -Y
例子：
源代码：
1 #include <stdio.h>
2
3 int main(int argc,char *argv[])
4 {
5 int nVarOne = argc;
6 int nVarTwo = 0;
7
8 scanf("%d",&nVarTwo);
9
10 nVarOne = nVarOne - 100;
11 nVarOne = nVarOne + 5 - nVarTwo;
12
13 printf("nVarOne = %d \r\n",nVarOne);
14
15 return 0;
16 }
汇编代码：Debug版
1 1: #include <stdio.h>
2 2:
3 3: int main(int argc,char *argv[])
4 4: {
5 0040D400 push ebp
6 0040D401 mov ebp,esp
7 0040D403 sub esp,48h
8 0040D406 push ebx
9 0040D407 push esi
10 0040D408 push edi
11 0040D409 lea edi,[ebp-48h]
12 0040D40C mov ecx,12h
13 0040D411 mov eax,0CCCCCCCCh
14 0040D416 rep stos dword ptr [edi]
15 5: int nVarOne = argc;
16 0040D418 mov eax,dword ptr [ebp+8]
17 0040D41B mov dword ptr [ebp-4],eax
18 6: int nVarTwo = 0;
19 0040D41E mov dword ptr [ebp-8],0
20 7:
21 8: scanf("%d",&nVarTwo);
22 0040D425 lea ecx,[ebp-8]
23 0040D428 push ecx
24 0040D429 push offset string "%d" (0042201c)
25 0040D42E call scanf (0040f940)
26 0040D433 add esp,8
27 9:
28 10: nVarOne = nVarOne - 100;
29 0040D436 mov edx,dword ptr [ebp-4]
30 0040D439 sub edx,64h
31 0040D43C mov dword ptr [ebp-4],edx
32 11: nVarOne = nVarOne + 5 - nVarTwo;
33 0040D43F mov eax,dword ptr [ebp-4]
34 0040D442 add eax,5
35 0040D445 sub eax,dword ptr [ebp-8]
36 0040D448 mov dword ptr [ebp-4],eax
37 12:
38 13: printf("nVarOne = %d \r\n",nVarOne);
39 0040D44B mov ecx,dword ptr [ebp-4]
40 0040D44E push ecx
41 0040D44F push offset string "nVar = %d \r\n" (00422e80)
42 0040D454 call printf (0040d6d0)
43 0040D459 add esp,8
44 14:
45 15: return 0;
46 0040D45C xor eax,eax
47 16: }
48 0040D45E pop edi
49 0040D45F pop esi
50 0040D460 pop ebx
51 0040D461 add esp,48h
52 0040D464 cmp ebp,esp
53 0040D466 call __chkesp (0040d690)
54 0040D46B mov esp,ebp
55 0040D46D pop ebp
56 0040D46E ret
乘法运算对于汇编为imul 和 mul。由于乘法指令的执行周期较长，在编译过程中，编译器会先尝试将乘法转换成加法，或使用移位等周期较短的指令。
当它们都不可转换时，才回使用乘法指令：
例子：
源代码：
1 #include <stdio.h>
2
3 int main(int argc,char *argv[])
4 {
5 int nVarOne = argc;
6 int nVarTwo = argc;
7
8 printf("nVarOne * 15 = %d \r\n",nVarOne * 15);
9
10 printf("nVarOne * 16 = %d \r\n",nVarOne * 16);
11
12 printf("2 * 2 = %d",2 * 2);
13
14 printf("nVarTwo * 4 + 5 = %d",nVarTwo * 4 + 5);
15
16 printf("nVarOne * nVarTwo = %d",nVarOne * nVarTwo);
17
18 return 0;
19 }
汇编代码：Debug版
1 1: #include <stdio.h>
2 2:
3 3: int main(int argc,char *argv[])
4 4: {
5 0040F9A0 push ebp
6 0040F9A1 mov ebp,esp
7 0040F9A3 sub esp,48h
8 0040F9A6 push ebx
9 0040F9A7 push esi
10 0040F9A8 push edi
11 0040F9A9 lea edi,[ebp-48h]
12 0040F9AC mov ecx,12h
13 0040F9B1 mov eax,0CCCCCCCCh
14 0040F9B6 rep stos dword ptr [edi]
15 5: int nVarOne = argc;
16 0040F9B8 mov eax,dword ptr [ebp+8]
17 0040F9BB mov dword ptr [ebp-4],eax
18 6: int nVarTwo = argc;
19 0040F9BE mov ecx,dword ptr [ebp+8]
20 0040F9C1 mov dword ptr [ebp-8],ecx
21 7:
22 8: printf("nVarOne * 15 = %d \r\n",nVarOne * 15);
23 0040F9C4 mov edx,dword ptr [ebp-4]
24 0040F9C7 imul edx,edx,0Fh
25 0040F9CA push edx
26 0040F9CB push offset string "nVarOne * 15 = %d \r\n" (0042304c)
27 0040F9D0 call printf (0040d6d0)
28 0040F9D5 add esp,8
29 9:
30 10: printf("nVarOne * 16 = %d \r\n",nVarOne * 16);
31 0040F9D8 mov eax,dword ptr [ebp-4]
32 0040F9DB shl eax,4
33 0040F9DE push eax
34 0040F9DF push offset string "nVarOne * 16 = %d \r\n" (00423034)
35 0040F9E4 call printf (0040d6d0)
36 0040F9E9 add esp,8
37 11:
38 12: printf("2 * 2 = %d",2 * 2);
39 0040F9EC push 4
40 0040F9EE push offset string "nVarOne = %d \r\n" (00422e80)
41 0040F9F3 call printf (0040d6d0)
42 0040F9F8 add esp,8
43 13:
44 14: printf("nVarTwo * 4 + 5 = %d",nVarTwo * 4 + 5);
45 0040F9FB mov ecx,dword ptr [ebp-8]
46 0040F9FE lea edx,[ecx*4+5] ;lea指令在汇编中的妙用，用于计算数值，简单
47 0040FA05 push edx
48 0040FA06 push offset string "nVarTwo * 4 + 5 = %d" (0042301c)
49 0040FA0B call printf (0040d6d0)
50 0040FA10 add esp,8
51 15:
52 16: printf("nVarOne * nVarTwo = %d",nVarOne * nVarTwo);
53 0040FA13 mov eax,dword ptr [ebp-4]
54 0040FA16 imul eax,dword ptr [ebp-8]
55 0040FA1A push eax
56 0040FA1B push offset string "nVarOne * nVarTwo = %d" (00423004)
57 0040FA20 call printf (0040d6d0)
58 0040FA25 add esp,8
59 17:
60 18: return 0;
61 0040FA28 xor eax,eax
62 19: }
63 0040FA2A pop edi
64 0040FA2B pop esi
65 0040FA2C pop ebx
66 0040FA2D add esp,48h
67 0040FA30 cmp ebp,esp
68 0040FA32 call __chkesp (0040d690)
69 0040FA37 mov esp,ebp
70 0040FA39 pop ebp
71 0040FA3A ret
1 printf("nVarTwo * 9 + 5 = %d",nVarTwo + 5);
2
3 0040B8F3 mov eax,dword ptr [ebp-8]
4 0040B8F6 imul eax,eax,9
5 0040B8F9 add eax,5
6 0040B8FC push eax
7 0040B8FD push offset string "nVarTwo * 9 + 5 = %d" (0041ff7c)
8 0040B902 call printf(0040b750)
9 0040B907 add esp,8
汇编代码:Release版
1 arg_0 = dword ptr 4
2
3
4 push esi
5 mov esi,[esp+4+arg_0]
6
7 lea eax,[esi+esi*2]
8 lea eax,[eax+eax*4]
9 push eax
10 push offset aNvarone15D ; "nVarOne * 15 = %d"
11 call _printf
12
13 mov ecx,esi
14 shl ecx,4
15 push ecx
16 push offset aNvarone16D ; "nVarOne * 16 = %d"
17 call _printf
18
19 push 4
20 push offset a22D ; "2 * 2 = %d"
21 call _printf
22
23 lea edx,ds:5[esi*4]
24 push edx
25 push offset aNvartwo45D ; "nVarTwo * 4 + 5 = %d"
26 call _printf
27
28 lea eax,[esi+esi*8+5]
29 push eax
30 push offset aNvartwo95D ; "nVarTwo * 9 + 5 = %d"
31 call _printf
32
33 mov ecx,esi
34 imul ecx,esi
35 push ecx
36 push offset aNvaroneNvarTwo ; "nVarOne * nVarTwo = %d"
37 call _printf
38
39 add esp,30h
40 pop esi
C++中的除法和数学中的除法不同。在C++中，除法运算不保留余数，有专门求取余数的运算（运算符%),就是取模运算。
对于整数除法，C++的规则是仅仅保留整数部分，小数部分完全舍弃
在C语言中的除法规则：
>两个无符号整数相除，结果依然为无符号
>两个有符号整数相除，结果则是有符号的
>有符号和无符号混除，结果则是无符号的，有符号的最高位（符号位）被作为数据对待，然后作为无符号数参与计算
对于处理小数部分计算机通常有几种方式：
>向下取整
就是取得 往 负无穷 方向的最接近x的整数值，也就是取得不大于x的最大值
数学中用[x]表示向下取整 ， C语言中用floor()函数(math.h),也被称为“地板取整”
但是向下取整存在一个问题：
-a a
[ —— ] != - [ —— ] 在a/b不为整数的情况下
b b
即 一正相除一负的取整不等于两正相除取整的负
>向上取整
同理，向上取整就是 正无穷 方向上最接近x的整数
C语言中 ceil（）函数，也被称为“天花板取整”
向下取整同样存在上面的问题：
-a a
[ —— ] != - [ —— ] 在a/b不为整数的情况下
b b
即 一正相除一负的取整不等于两正相除取整的负
>向零取整
就是取得 向0方向上 最接近于x的整数值。也就是放弃小数
向零取整除法满足：
-a a a
[ —— ] = [ —— ] = - [ —— ]
b -b b
在C语言和其他很多语言中对整数除法规定为向零取整。也被称为“截断除法”
1 #include <stdio.h>
2
3 int main()
4 {
5 printf("8 %% -3 = %d\r\n", 8 % -3); //2
6 printf("-8 %% -3 = %d\r\n", -8 % -3); //-2
7 printf("-8 %% 3 = %d\r\n",-8 % 3); //-2
8
9 return 0;
10 }
设被除数为a，除数为b，商为q，余数为r，则有以下性质：
> |r| < |b|
> a = b*q + r
>b = (a - r) / q
>q = (a - r) / b
>r = a - q*b
我们计算就要按着这个公式，当然可以巧记（取模运算符号和被除数的一致）
看下面例子：
源代码：
1 #include <stdio.h>
2
3 int main(int argc,char *argv[])
4 {
5 int nVarOne = argc;
6 int nVarTwo = argc;
7
8 printf("nVarOne / nVarTwo = %d",nVarOne/nVarTwo);
9 printf("nVarOne / 2 = %d",nVarOne / 2);
10 printf("nVarTwo / 7 = %d",nVarTwo / 7);
11 printf("nVarTwo % 7 = %d",nVarTwo % 7);
12 printf("nVarOne / 8 = %d",nVarOne / 8);
13
14 return 0;
15 }
汇编代码：
1 1: #include <stdio.h>
2 2:
3 3: int main(int argc,char *argv[])
4 4: {
5 0040D710 push ebp
6 0040D711 mov ebp,esp
7 0040D713 sub esp,48h
8 0040D716 push ebx
9 0040D717 push esi
10 0040D718 push edi
11 0040D719 lea edi,[ebp-48h]
12 0040D71C mov ecx,12h
13 0040D721 mov eax,0CCCCCCCCh
14 0040D726 rep stos dword ptr [edi]
15 5: int nVarOne = argc;
16 0040D728 mov eax,dword ptr [ebp+8]
17 0040D72B mov dword ptr [ebp-4],eax
18 6: int nVarTwo = argc;
19 0040D72E mov ecx,dword ptr [ebp+8]
20 0040D731 mov dword ptr [ebp-8],ecx
21 7:
22 8: printf("nVarOne / nVarTwo = %d",nVarOne/nVarTwo);
23 0040D734 mov eax,dword ptr [ebp-4]
24 0040D737 cdq ;扩展高位
25 0040D738 idiv eax,dword ptr [ebp-8]
26 0040D73B push eax
27 0040D73C push offset string "nVarOne / nVarTwo = %d" (00422ff0)
28 0040D741 call printf (00401080)
29 0040D746 add esp,8
30 9: printf("nVarOne / 2 = %d",nVarOne / 2);
31 0040D749 mov eax,dword ptr [ebp-4]
32 0040D74C cdq
33 0040D74D sub eax,edx
34 0040D74F sar eax,1
35 0040D751 push eax
36 0040D752 push offset string "nVarOne / 2 = %d" (00422fdc)
37 0040D757 call printf (00401080)
38 0040D75C add esp,8
39 10: printf("nVarTwo / 7 = %d",nVarTwo / 7);
40 0040D75F mov eax,dword ptr [ebp-8]
41 0040D762 cdq
42 0040D763 mov ecx,7
43 0040D768 idiv eax,ecx
44 0040D76A push eax
45 0040D76B push offset string "nVarTwo / 7 = %d" (00422044)
46 0040D770 call printf (00401080)
47 0040D775 add esp,8
48 11: printf("nVarTwo % 7 = %d",nVarTwo % 7);
49 0040D778 mov eax,dword ptr [ebp-8]
50 0040D77B cdq
51 0040D77C mov ecx,7
52 0040D781 idiv eax,ecx
53 0040D783 push edx
54 0040D784 push offset string "nVarTwo % 7 = %d" (00422030)
55 0040D789 call printf (00401080)
56 0040D78E add esp,8
57 12: printf("nVarOne / 8 = %d",nVarOne / 8);
58 0040D791 mov eax,dword ptr [ebp-4]
59 0040D794 cdq
60 0040D795 and edx,7
61 0040D798 add eax,edx
62 0040D79A sar eax,3
63 0040D79D push eax
64 0040D79E push offset string "nVarOne / 8 = %d" (0042201c)
65 0040D7A3 call printf (00401080)
66 0040D7A8 add esp,8
67 13:
68 14: return 0;
69 0040D7AB xor eax,eax
70 15: }
71 0040D7AD pop edi
72 0040D7AE pop esi
73 0040D7AF pop ebx
74 0040D7B0 add esp,48h
75 0040D7B3 cmp ebp,esp
76 0040D7B5 call __chkesp (00401100)
77 0040D7BA mov esp,ebp
78 0040D7BC pop ebp
79 0040D7BD ret
1 M与-M在计算机中的表示是互为补码的
2 即 [-M]=[M]补
3 因此 ，[M]/2分2个情况考虑
4 1，M为正数，正数的除法就是算术右移一位
5 mov eax , M
6 sar eax,1 //右移1位，即除以2
7 2，M为负数，则[M]/2= [ [-M]/2 ]补 = [-[[M]补/2] ]补
8 M为负数，所以，上面的计算过程是：
9 M取反加1，算术右移1位，再取反加1
10 设M为1字节
11 M取反加1可以表示成 (FF-M+1)
12 因此，上面的计算过程转化为
13 FF - ( (FF-M+1)/2 ) +1 = FF-(FF/2) + (M+1)/2
14 这里的 /2意思为向右带符号移一位，而FF 算术右移1位还是FF
15 所以可以简化为
16 (M+1)/2
17 注意，这里的M是负数
18 所以：
19 mov eax, M
20 sub eax,-1 //减-1就是+1
21 sar eax,1 //右移1位，除以2
22 然后解释一下 CDQ指令就可以了
23 当EAX >=0 ,CDQ结果 EDX=0
24 当EAX < 0 ,CDQ结果 EDX=-1
25 因此，M/2可以写成
26 mov eax, M
27 cdq //扩展符号位，到EDX
28 sub eax,edx //EAX>0 ,则EAX - 0 ;EAX<0 ,则EAX - (-1)
29 sar eax,1 //右移2位
有一种落差是，你配不上自己的野心，也辜负了所受的苦难
