十进制数转16进制数

先以二进制数转十进制数为例：

80 = 2^6 + 2^4    则D6 = 1, D4 = 1, 其余位为0 ，80的二进制代码为 0101 0000

则，10进制转16进制，

10进制数 = 16^n + 16^x，以255为例

255 = 15 * 16^1+ 15 * 16^0    求得 255的16进制数为 FFH， 0次幂代表 H0的位置，15代表该位置上的值，15的16进制数为F，同理1次幂代表H1的位置，前面的倍数代表该位的值

 由于二进制中倍数的值只有0，1所以省略，同理10进制转16进制的过程中，倍数的取值为0--15

注意：在使用这种方法进行数制转换的过程中，需要让每一个相加的数保持最大，它们的和等于最终的十进制数的值

条件码标志

CF （carry flag）进位标志位，用于判断最高位是否有进位或借位，若有CF =1，若没有CF=0

OF （overflow flag）溢出标志位，用于判断计算结果是否发送溢出，若溢出OF =1， 若没有OF =0

AF （auxiliary carry flag）辅助进位标志，用于判断低四位是否向高四位进位，若有AF = 1，若没有AF =0

SF (signal flag)符号标志，用于判断符号位，若为负，SF =1, 若为正SF =0

ZF （zero flag）零标志，用于判断运算结果是否为 0 ，若运算结果为0, ZF = 1, 若运算结果不为0，ZF = 0

PF （parity flag）奇偶标志，运算结果中，若最低字节（低八位）中1的个数为0或为偶数时，PF =1，若最低字节中1的个数为奇数时，PF =0

字与字节

字 = n 个字节 （n=1,2,4,8）

一个字节是八位二进制数

乘法指令

无符号数与有符号数

无符号数：无符号数是一种不设符号位的正整数，所有的位都用来表示数值，对字长为n位的无符号数，其表示范围是0~2^n -1

有符号数：最高位为符号位，一般用0表示正数，用1表示负数

无符号数乘法指令  MUL R/M

字节乘法： AX <--- AL *SRC;

字乘法： DX, AX <--- AX *SRC

该指令只对CF, OF 有定义，其余状态无定义，若高半部分，字节乘法的AH，字乘法的DX，不为零，则表明其结果为有效位，CF = OF = 1, 否则 CF = OF =0

有符号数乘法指令IMUL R/M

该指令实现两个有符号数之间的乘法，被乘数隐含在AX/AL中，运算结果存储在AX或AX和DX中；

该指令只对CF, OF有定义，其余状态无定义，若高半部分，字节乘法（8位）的AH，字乘法（16位）的DX，是低一半的符号扩展，则OF = CF = 0，否则， OF = CF =1

有符号乘法指令将操作数视为补码表示的有符号整数，按补码乘法规则进行，积也是补码表示的有符号整数

同样的二进制数，看作有符号数和无符号数分别做乘法时结果不同

什么是符号扩展

不改变正负和数值大小，仅将位数由字节变为字，或由字变为双字

符号扩展指令

用于不同操作数运算和除法指令所需的被除数

CBW --> 字节 ——>字

CWD --> 字 ——>双字

符号扩展指令不影响标志位，对有符号数增加位数，数据大小不变

扩展方法

CBW ,将低八位（AL）中的最高位拓展到AH，AL不变；若D7=0，（D0--D7是表示低8位的符号），则AH =00H, 若D7=1, 则AH=FFH

实例如下：采用汇编语言展示

MOV AL, 80H  
CBW
ADD AL, 255
CBW

指令一：MOV AL, 80H  即 AL = 80H        此处80H为十六进制数，H为16进制数标志，80H转为二进制为

1000 0000 ，如图所示，D7=1, 则AH=FFH

指令二 CBW  运行结果为，AH = FFH,  AL= 80H

指令三 ADD AL, 255 

运算结果： 80H + FFH = 17FH    由于低位返回给AL, 则AL = 7FH， 1存到DX中 DX=01H

此处255为十进制数，把它转为16进制数为FFH

十进制数转16进制数

先以二进制数转十进制数为例：

80 = 2^6 + 2^4    则D6 = 1, D4 = 1, 其余位为0 ，80的二进制代码为 0101 0000

则，10进制转16进制，

10进制数 = 16^n + 16^x，以255为例

255 = 15 * 16^1+ 15 * 16^0    求得 255的16进制数为 FFH， 0次幂代表 H0的位置，15代表该位置上的值，15的16进制数为F，同理1次幂代表H1的位置，前面的倍数代表该位的值

 由于二进制中倍数的值只有0，1所以省略，同理10进制转16进制的过程中，倍数的取值为0--15

注意：在使用这种方法进行数制转换的过程中，需要让每一个相加的数保持最大，它们的和等于最终的十进制数的值

指令四 CBW

对AL进行符号扩展，AL=7FH, 7FH的二进制数为01111111，D7=0，则AH = 00H,  AX = 007FH

具体是如何转换的请看小标题——扩展方法

个人易混淆点

CL，计数寄存器

CS，代码段寄存器

十六进制乘除法牢记一点，满16进一，借位为16

经理的皮鞋湿了，但是却没有变胖，所以经理的皮鞋是人造革的。

刚刚写了一篇文章：
不依赖OS编译器，不依赖库，用汇编/机器码直接编程： https://blog.csdn.net/dog250/article/details/89500153

展示了一个直接执行二进制指令文件的基本方案，基于Linux内核来执行。

值得一提的是，这不是什么特别有技术含量的东西，这只是一个基本功，我在2006年的长春吉林大学边上租住的房子里就玩过此法。那时是用VC 6。

大公司的程序员不会屑于写我这些淫巧，即便他们也不一定会，也不一定懂，他们只是太关注业务，也许是真的没时间，也许真的就是不屑，觉得这太简单。但是，我的意思就是，这些东西真的太简单，如果你不懂，那真的不是一个合格的程序员。

本文写一个 解释器 ，载入一个仅包含二进制指令的文件，然后执行，这非常简单。

有两种方法可以简单的改变程序的执行流：

1. 通过替换函数调用的返回地址。
   这是call指令提供的功能，call指令执行时，会将下一条指令压栈，我们只需要在栈里找到这个位置，将其替换为自己的指令即可。
2. 直接通过内联汇编调用jmp指令执行自己的指令。
   这个非常直接，超级简单。

首先看第一个方法，代码如下：

#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>

// 我们想直接执行这段指令，当然，它保存于某个文件，可以从文件里读出到code内存空间。
// char nop[] = {0x48, 0xc7, 0xc0, 0x3c, 0x00, 0x00, 0x00, 0x48, 0x31, 0xff, 0x0f, 0x05};
unsigned char *code;
void exec()
{
	unsigned long a, *p;
	// 替换返回地址，使得exec返回的时候，跳转到我们的代码。
	p = (void*)((long)&a + 24);
	*p = (unsigned long)code;
}

int main(int argc, char **argv)
{
	FILE *fp = NULL;

	fp = fopen(argv[1], "r");
	// 映射地址空间
	code = (unsigned char*)mmap(0, 1024, PROT_READ|PROT_WRITE|PROT_EXEC, MAP_ANON|MAP_PRIVATE, 0, 0);
	//memcpy(code, nop, sizeof(nop));
	// 将指令文件内容读取到code指示的地址空间。
	fread(code, 1024, 1, fp);
	// 执行之
	exec();
	printf("end\n");
}

接下来看看直接jmp的方式，依然是一个很简单的代码：

#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>

// 我们想直接执行这段指令，当然，它保存于某个文件，可以从文件里读出到code内存空间。
//char nop[] = {0x48, 0xc7, 0xc0, 0x3c, 0x00, 0x00, 0x00, 0x48, 0x31, 0xff, 0x0f, 0x05};
unsigned char *code;

int main(int argc, char **argv)
{
	FILE *fp = NULL;

	fp = fopen(argv[1], "r");
	code = (unsigned char*)mmap(0, 1024, PROT_READ|PROT_WRITE|PROT_EXEC, MAP_ANON|MAP_PRIVATE, 0, 0);
	// memcpy(code, nop, sizeof(nop));
	fread(code, 1024, 1, fp);

	asm ( "jmp %0"
          :           
          :"r"(code)
          :);

	printf("end\n");
}

将上述的代码编译成一个比如a.out的程序，将一个二进制指令文件作为参数执行之，就会看到效果了。

我来准备一个二进制指令文件，以fork炸弹为例：

.global _start
_start:
	mov     $57, %rax               # fork 炸弹
	syscall
	jmp _start

照常编译：

[root@localhost ~]# as --64 -o forkbomb.o forkbomb.s
[root@localhost myflat]# ld -melf_x86_64 -o forkbomb forkbomb.o --oformat=binary

然后将这个forkbomb作为参数执行a.out，试试看。

值得注意的是，以上的例子中，我没有为指令文件里的指令分配独立的stack空间，而是借用了a.out主进程的stack空间，所有的pop，push等指令，都会操作a.out主进程的stack。

其实，更优雅的方案是，单独分配一个新的stack空间，切过去，皮鞋就干了。

有人会说这样做没有内核方案直接。确实是的，毕竟我们无法直接在bash的命令提示符里输入forkbomb那般执行，但是想达到这个效果，这也不难啊。

你在命令提示符里输入的任何程序都是通过bash来执行的，我们把上述的a.out整个儿给塞进bash中不就OK了吗？在bash开始fork/exec新进程的时候，自己完成mmap，memcpy的事情，然后要么通过替换函数返回地址后主动return，要么直接内联汇编里jmp，不就OK了么。

非常简单！

请注意，埃里克.雷蒙德有枪！

皮鞋湿，不会胖！但是经理的皮鞋除外。埃里克.雷蒙德也不懂皮鞋，毕竟，第一次穿。

理解二进制的“逢二进一”

二进制和咱们平时用的十进制，其实并没有什么本质区别，只是平时咱们是“逢十进一”，这里变成了“逢二进一”而已。每一位，相比于十进制下的 0～9 这十个数字，咱们只能用 0 和 1 这两个数字。

任何一个十进制的整数，都能通过二进制表示出来。把一个二进制数，对应到十进制，非常简单，就是把从右到左的第 N 位，乘上一个 2 的 N 次方，然后加起来，就变成了一个十进制数。当然，既然二进制是一个面向程序员的“语言”，这个从右到左的位置，自然是从 0 开始的。

比如 0011 这个二进制数，对应的十进制表示，就是 0×23+0×22+1×21+1×20=3，代表十进制的 3。

对应地，如果咱们想要把一个十进制的数，转化成二进制，使用短除法就可以了。也就是，把十进制数除以 2 的余数，作为最右边的一位。然后用商继续除以 2，把对应的余数紧靠着刚才余数的右侧，这样递归迭代，直到商为 0 就可以了。

比如，咱们想把 13 这个十进制数，用短除法转化成二进制，需要经历以下几个步骤：
因此，对应的二进制数，就是 1101。

上面咱们举的例子都是正数，对于负数来说，情况也是一样的吗？咱们可以把一个数最左侧的一位，当成是对应的正负号，比如 0 为正数，1 为负数，这样来进行标记。

这样，一个 4 位的二进制数， 0011 就表示为 +3。而 1011 最左侧的第一位是 1，所以它就表示 -3。这个其实就是整数的原码表示法。原码表示法有一个很直观的缺点就是，0 可以用两个不同的编码来表示，1000 代表 0， 0000 也代表 0。习惯万事一一对应的程序员看到这种情况，必然会被“逼死”。

于是，我们就有了另一种表示方法。我们仍然通过最左侧第一位的 0 和 1，来判断这个数的正负。但是，我们不再把这一位当成单独的符号位，在剩下几位计算出的十进制前加上正负号，而是在计算整个二进制值的时候，在左侧最高位前面加个负号。

比如，一个 4 位的二进制补码数值 1011，转换成十进制，就是 −1×23+0×22+1×21+1×20=−5。如果最高位是 1，这个数必然是负数；最高位是 0，必然是正数。并且，只有 0000 表示 0，1000 在这样的情况下表示 -8。一个 4 位的二进制数，可以表示从 -8 到 7 这 16 个整数，不会白白浪费一位。

当然更重要的一点是，用补码来表示负数，使得咱们的整数相加变得很容易，不需要做任何特殊处理，只是把它当成普通的二进制相加，就能得到正确的结果。咱们简单一点，拿一个 4 位的整数来算一下，比如 -5 + 1 = -4，-5 + 6 = 1。咱们各自把它们转换成二进制来看一看。如果它们和无符号的二进制整数的加法用的是同样的计算方式，这也就意味着它们是同样的电路。

字符串的表示，从编码到数字

不仅数值可以用二进制表示，字符乃至更多的信息都能用二进制表示。最典型的例子就是字符串（Character String）。最早计算机只需要使用英文字符，加上数字和一些特殊符号，然后用 8 位的二进制，就能表示我们日常需要的所有字符了，这个就是我们常常说的 ASCII 码（American Standard Code for Information Interchange，美国信息交换标准代码）。
ASCII 码就好比一个字典，用 8 位二进制中的 128 个不同的数，映射到 128 个不同的字符里。比如，小写字母 a 在 ASCII 里面，就是第 97 个，也就是二进制的 0110 0001，对应的十六进制表示就是 61。而大写字母 A，就是第 65 个，也就是二进制的 0100 0001，对应的十六进制表示就是 41。

在 ASCII 码里面，数字 9 不再像整数表示法里一样，用 0000 1001 来表示，而是用 0011 1001 来表示。字符串 15 也不是用 0000 1111 这 8 位来表示，而是变成两个字符 1 和 5 连续放在一起，也就是 0011 0001 和 0011 0101，需要用两个 8 位来表示。

咱们可以看到，最大的 32 位整数，就是 2147483647。如果用整数表示法，只需要 32 位就能表示了。但是如果用字符串来表示，一共有 10 个字符，每个字符用 8 位的话，需要整整 80 位。比起整数表示法，要多占很多空间。

这也是为什么，很多时候我们在存储数据的时候，要采用二进制序列化这样的方式，而不是简单地把数据通过 CSV 或者 JSON，这样的文本格式存储来进行序列化。不管是整数也好，浮点数也好，采用二进制序列化会比存储文本省下不少空间。

ASCII 码只表示了 128 个字符，一开始倒也堪用，毕竟计算机是在美国发明的。然而随着越来越多的不同国家的人都用上了计算机，想要表示譬如中文这样的文字，128 个字符显然是不太够用的。于是，计算机工程师们开始各显神通，给自己国家的语言创建了对应的字符集（Charset）和字符编码（Character Encoding）。

字符集，表示的可以是字符的一个集合。比如“中文”就是一个字符集，不过这样描述一个字符集并不准确。想要更精确一点，我们可以说，“第一版《新华字典》里面出现的所有汉字”，这是一个字符集。这样，咱们才能明确知道，一个字符在不在这个集合里面。比如，我们日常说的 Unicode，其实就是一个字符集，包含了 150 种语言的 14 万个不同的字符。

而字符编码则是对于字符集里的这些字符，怎么一一用二进制表示出来的一个字典。咱们上面说的 Unicode，就可以用 UTF-8、UTF-16，乃至 UTF-32 来进行编码，存储成二进制。所以，有了 Unicode，其实咱们可以用不止 UTF-8 一种编码形式，咱们也可以自己发明一套 GT-32 编码，比如就叫作 Geek Time 32 好了。只要别人知道这套编码规则，就可以正常传输、显示这段代码。
同样的文本，采用不同的编码存储下来。如果另外一个程序，用一种不同的编码方式来进行解码和展示，就会出现乱码。这就好像两个军队用密语通信，如果用错了密码本，那看到的消息就会不知所云。在中文世界里，最典型的就是“手持两把锟斤拷，口中疾呼烫烫烫”的典故。

有时候没有经验的在看到程序输出“烫烫烫”的时候，以为是程序让 CPU 过热发出报警，于是尝试给 CPU 降频来解决问题。

既然今天要彻底搞清楚编码知识，咱们就弄清楚“锟斤拷”和“烫烫烫”的来龙去脉。
首先，“锟斤拷”的来源是这样的。如果咱们想要用 Unicode 编码记录一些文本，特别是一些遗留的老字符集内的文本，但是这些字符在 Unicode 中可能并不存在。于是，Unicode 会统一把这些字符记录为 U+FFFD 这个编码。如果用 UTF-8 的格式存储下来，就是\xef\xbf\xbd。如果连续两个这样的字符放在一起，\xef\xbf\xbd\xef\xbf\xbd，这个时候，如果程序把这个字符，用 GB2312 的方式进行 decode，就会变成“锟斤拷”。这就好比咱们用 GB2312 这本密码本，去解密别人用 UTF-8 加密的信息，自然没办法读出有用的信息。

而“烫烫烫”，则是因为如果你用了 Visual Studio 的调试器，默认使用 MBCS 字符集。“烫”在里面是由 0xCCCC 来表示的，而 0xCC 又恰好是未初始化的内存的赋值。于是，在读到没有赋值的内存地址或者变量的时候，电脑就开始大叫“烫烫烫”了。

了解了这些原理，相信你以后在遇到中文的编码问题的时候，可以做到“手中有粮，心中不慌”了。

总结

咱们可以用二进制编码的方式，表示任意的信息。只要建立起字符集和字符编码，并且得到大家的认同，咱们就可以在计算机里面表示这样的信息了。

不过光是明白怎么把数值和字符在逻辑层面用二进制表示是不够的。咱们在计算机组成里面，关心的不只是数值和字符的逻辑表示，更要弄明白，在硬件层面，这些数值和咱们一直提的晶体管和电路有什么关系。