本节我们利用反汇编技术来对我们最常见的C语言语句进行解析，C++反汇编技术可以让你更好的理解C++/C语言的底层含义，相信我，读完本节，一定会让你感到醍醐灌顶，瞬间通透C++/C语言的底层含义
我们假设你已经基本了解了x86汇编的基本指令：
mov ax,06h： 基本赋值指令 ax=0006h
add ax,cx： 相加指令：ax=ax+cx
sub ax,cx： 相减指令：ax=ax-cx
call 地址： 跳转指令：跳转到这个地址位置，常用于跳转到函数
ret ： 跳转指令：和call指令配合使用，相当于return，从函数返回
jmp 地址： jmp：无条件跳转指令，跳转到此地址
jne | je ： 有条件跳转指令，jne表示如果nor equal则跳转，je表示如果equal则跳转
lea ax,[地址]：地址赋值指令，把这个地址赋值给ax
等等等等…
基本汇编单位：
int a = 10;
int b = 20;
就是这么简单的两条赋值语言，你知道他在汇编里是什么样的吗？
mov dword ptr [a],0Ah
mov dword ptr [b],14h
我们把十六进制的 0Ah（H：10）送到 a所表示的内存地址空间。
我们把十六进制的14h（H：20）送到b表示的内存地址空间
dword ptr表示他们是四个字节，正好可以表示出：我们的int类型的sizeof(int)为4，即4个字节。
if (a == b)
{
printf("a==b");
}
else
{
printf("a!=b");
}
它的汇编指令是怎样的呢？
mov eax,dword ptr [b] //b的内存空间里的内容送往eax寄存器
cmp dword ptr [a],eax // cmp和a内存空间里的内容比较
jne __$EncStackInitStart+52h (07FF7C6895CB1h) //如果不相等，则跳转,否则，继续往下执行
lea rcx,[string "a==b" (07FF7C689AE38h)] //将表示字符串的地址赋值给rcx，配合下面的跳转到printf的函数打印此字符串
call printf (07FF7C6891195h)
07FF7C6895CB1h: jmp __$EncStackInitStart+5Eh (07FF7C6895CBDh) //cmp相等则直接跳转到此处
lea rcx,[string "a!=b" (07FF7C689AE40h)]
call printf (07FF7C6891195h)
我们来分析一下：
cmp指令的执行过程不会这么简单，它也包含复杂的比较条件，在此我们不再赘述。
一个很重要的问题： 引用就是指针，为什么？
int c = 5;
int d = 15;
int* p1 = &c;
int& p2 = d;
看一下汇编代码：
mov dword ptr [c],5
mov dword ptr [d],0Fh
//指针的操作
lea rax,[c] //将c的地址值给rax
mov qword ptr [p1],rax //将rax（c的地址值）给p1所在的内存空间
//引用的操作
lea rax,[d]
mov qword ptr [p2],rax
注意： 指针和引用的内存空间里存储的是c和d的地址，我们再通过解引用，从他们的内存空间中获取c和d的地址，这就是我们所知道的指针赋值和解引用操作。
大家有没有注意到一个问题： 指针和引用的汇编指令是一样的：
lea 寄存器，[地址值]
mov qword ptr [指针变量地址],寄存器
他们的汇编指令一样，所以说他们的实质是一样的： 引用的本质就是指针。
同时，如果我们看到这两条指令，则99%的概率是引用或者指针在赋值。
void fun()
{
int a = 10;
int c = 20;
a += c;
}
int main()
{
fun();
return 0;
}
call fun (07FF63C6A13FCh) //函数跳转
..............
.....
//int a=10;
mov dword ptr [a],0Ah
//int b=20;
mov dword ptr [c],14h
//a=a+c;
mov eax,dword ptr [c]
mov ecx,dword ptr [a]
add ecx,eax
mov eax,ecx
mov dword ptr [a],eax
....
ret //返回主程序
我们进入函数时，实际上就是call 一个地址，这个地址指向的就是我们的函数地址，然后进入函数，我们完成对int类型的a和c的赋值，接着我们在完成 a+=c的操作：
分解：
为什么不能把 [a]和[c]直接相加呢？为什么还要借助好几个寄存器中转？在最后，我们会有 一个ret的指令，此指令 完成return的返回操作，即返回主程序。
这是一个我们非常熟悉的两数字交换的指针操作：
void swap(int* a, int* b)
{
int temp = *a;
*a = *b;
*b = temp;
}
//传递形参地址
lea rdx,[b] //取b的地址给rdx寄存器
lea rcx,[a] //取a的地址给rcx寄存器
call swap (07FF721F1132Fh) //进入函数
.....
...
//int temp=*a;
mov rax,qword ptr [a]
mov eax,dword ptr [rax]
mov dword ptr [temp],eax
//*a=*b;
mov rax,qword ptr [a]
mov rcx,qword ptr [b]
mov ecx,dword ptr [rcx]
mov dword ptr [rax],ecx
//*b=temp;
mov rax,qword ptr [b]
mov ecx,dword ptr [temp]
mov dword ptr [rax],ecx
...
ret
解析：
进入函数时，如果我们有形参，并且是指针类型，我们要完成对形参的取地址的行为，即用lea指令获得地址，分别存储在两个寄存器中。
int temp=*a 的操作过程：
*a=*b的操作过程：
*b=temp的过程：
int ar[5]={0};
是如何进行的呢？
lea rax,[ar]
mov rdi,rax
xor eax,eax
mov ecx,14h
rep stos byte ptr [rdi]
rep stos指令的作用：重复执行上述指令，以ecx的值为执行次数，把eax的值送到之后的目标地址处。
把ar的地址送到rax寄存器中，注意：ar表示的是数组首地址，rax表示的是数组的首地址，再把rax送到rdi所造的内存单元，即rdi所在的内存单元里存储者数组的首地址，通过这个地址，我们可以根据偏移来获得整个数组的地址。
eax表示我们要送往目标的值，我们一共要重复执行ecx次：即20次
注意：我们每次移动一个 byte ptr：即一个字节，但是我们的数组每个元素都是int，所以每个元素会执行4次，一共执行20次，正好和ecx总的重复次数相对应。
我们通过看内存可以得知：
数组的初始内存全部都是CCCC…， 即我们的eax默认也是存放的eax，我们对eax执行XOR操作（异或操作），
异或操作： 两数相同则为0，两数相异则为1 .
我们对eax和eax执行异或操作，每次执行一个字节，执行过程如下：
二进制数中，开始1表示负数，0表示正数
eax： CCCC CCCC
原码：1100 1100 1100 1100 1100 1100 1100 1100
反码：1011 0011 0011 0011 0011 0011 0011 0011 （对第二个数往后的数取反，第一个数是符号位）
补码：1011 0011 0011 0011 0011 0011 0011 0100 （反码在最后加1，得到补码）
第一个数字表示符号位： 负数
计算除第一位以外的补码转换为十进制：
第二个数字开始，转换为十进制，（再加上最开始的符号位）我们会发现一个挺熟悉的值： - 858993460
这是个啥？？
如果我们打印一个未经初始化的数组的值：
int ar[5] ;
for (int i = 0; i < 5; i++)
{
cout << ar[i]<<" ";
}
它的值就是 -858993460 这个值。
接着我们回到这段汇编上来：
一共执行20次，注意：·我们每次处理一个字节！！
- 858,993,664
-859045888
-872415232
0
这样我们就完成了对数组首元素的赋值，接着我们循环执行ecx次，即20次，再完成对剩下4个 赋值为0
本节内容比较硬核，解释了底层C语言的语句执行情况，在此后，我也会写很多有意义的C++反汇编的代码，帮助大家理解C/C++的底层含义。