机器语言

进制

进制如何运算

二进制

运算的本质就是查数
HEX: 16
DEC: 10
OCT: 8
BIN: 2
image.png
可以实现量子计算的机器
传统计算机，集成电路，硅晶片 -> 计算速度有限，并发语法诞生
光子
磁场

量子比特。量子叠加态，量子纠缠，量子并行原理

  1. # 二进制 0   1111(16)
  3. 0  1  10  11  100  101  110  111  1000  1001  1010  1011  1100  1101  1110  1111  ...  
  4. # 后面就是重复循环
  6. # 简化 => 16进制(0x前缀  oxFF  =  255)
  8. 0  1   2   3    4    5    6    7     8     9     a     b     c     d     e     f
  10. # 二进制标志位
  11. 2  10
  12. 4  100
  13. 8  1000
  15. 0000 0000 0000 0000

数据宽度

强类型语言： 数据类型，定义数据宽度
位： 0 - 1
字节： 0 - 0xFF(255)
字： 0 - 0xFFFF
双字： 0 - 0xFFFFFF
每一个数据都需要定义类型，定义宽度，内存中的宽度。

有符号数、无符号数

无符号数规则

有符号数规则

最高位是符号位，1（负数），0（正数）

原码反码补码

原码：最高位是符号位，其它位取绝对值即可
反码：

  • 正数：反码和原码相同
  • 负数：符号位一定是1，其余位对原码取反。

补码：

  • 正数：补码和原码相同
  • 负数：符号位一定是1，反码 + 1。 ```shell

    8位

正数的原码、反码、补码都一样

正数: 1 原码: 0 0 0 0 0 0 0 1 反码: 0 0 0 0 0 0 0 1 补码: 0 0 0 0 0 0 0 1 # 计算机存储的是补码

负数

负数: -1 原码: 1 0 0 0 0 0 0 1 反码: 1 1 1 1 1 1 1 0 补码: 1 1 1 1 1 1 1 1 # 对原码的反码 + 1

负数: -7 原码: 1 0 0 0 0 1 1 1 反码: 1 1 1 1 1 0 0 0 补码: 1 1 1 1 1 0 0 1

  1. ![image.png](https://cdn.nlark.com/yuque/0/2021/png/2932776/1634102444216-a49bdc3c-cf5c-408e-b4cc-a0cf29657e99.png#clientId=u21167dc7-ba4a-4&from=paste&height=313&id=u70cd2975&margin=%5Bobject%20Object%5D&name=image.png&originHeight=625&originWidth=564&originalType=binary&ratio=1&size=289174&status=done&style=none&taskId=u4ea0dc62-8e96-4ff2-a891-71e8574692a&width=282)
  4. <a name="eEQBE"></a>
  5. # 位运算
  6. <a name="BOi49"></a>
  7. ## 与运算（and 、&）
  8. ```shell
  9. # 两个都为1，结果位1
  10. 1011 0011
  11. 1010 1101
  12. ----------- 与运算
  13. 1010 0001

或运算（or、 |）

  1. # 只要有一个为1，结果为1
  2. 1011 0011
  3. 1010 1101
  4. ----------- 或运算
  5. 1011 1111

异或运算（XOR 或 EOR、^）

非0即1，非1即0，（不一样就是1）
XOR它指的是逻辑运算中的“异或运算”。两个值相同时，返回false，否则返回 true，用来判断两个值是否不同。
JavaScript语言的二进制运算，有一个专门的 XOR 运算符，写作^。

  1. 1 ^ 1 // 0
  2. 0 ^ 0 // 0
  3. 1 ^ 0 // 1
  4. 0 ^ 1 // 1
  6. # 非0即1，非1即0，（不一样就是1）
  7. 1011 0011
  8. 1010 1101
  9. ----------- 异或运算
  10. 0001 1110

XOR 运算有一个特性：如果对一个值连续做两次 XOR，会返回这个值本身。这也是其可以用于信息加密的根本。

关于异或运算有下面几个规律
1^1=0;
1^0=1;
0^1=1;
0^0=0;
也就说0和1异或的时候相同的异或结果为0，不同的异或结果为1，根据上面的规律我们得到
a^a=0；自己和自己异或等于0
a^0=a；任何数字和0异或还等于他自己
a^b^c=a^c^b；异或运算具有交换律

双目运算： 与运算、或运算、异或运算 单目运算： 非运算

非运算（not、 ~）

  1. # 取反，0就是1，1就是0
  2. 1011 0011
  3. ----------- 取反运算
  4. 0100 1100

位运算（移动位）

  1. 0000 0001    1
  2. 0000 0010    2
  3. 0000 0100    4
  4. 0000 1000    8
  6. # 对于10进制来说，左移就是*2，右移就是/2
  8. # 左移  shl << 
  9. # 所有二进制位全部左移，高位丢弃，低位补0
  11. # 右移  shr >>
  12. # 所有二进制位全部右移，低位丢弃，高位补0，1（根据符号位决定）

位运算的加减乘除

异或 -> 与(判断进位) -> 左移(与运算的结果左移) -> 异或(上一次异或的结果和上一次左移的结果) -> 与 -> ……

  1. # 4 + 5 ?
  2. 0000 0100
  3. 0000 0101
  4. ---------- +
  5. 0000 1001
  7. # 计算机是怎么操作的
  8. # 第一步： 异或： 如果不考虑进位，异或就可以直接出结果
  9. 0000 0100
  10. 0000 0101
  11. ---------- 异或
  12. 0000 0001
  14. # 第二步： 与运算： 判断进位(如果与运算结果为0，则没有进位，结果就是上一个异或运算的结果)
  15. 0000 0100
  16. 0000 0101
  17. ---------- 与运算
  18. 0000 0100
  20. # 第三步： 将与运算的结果左移一位，得到进位的结果  0000 1000  
  21. 0000 0100 << 1 = 0000 1000 
  23. # 第四步： 异或(第一步异或的结果、第三步与运算的进位结果)
  24. 0000 0001
  25. 0000 1000 
  26. ---------- 异或
  27. 0000 1001
  29. # 到这里还没有结束
  30. -------------------------------
  31. # 第五步： 与运算： 判断进位(如果与运算结果为0，则没有进位，结果就是上一个异或运算的结果)
  32. 0000 0001
  33. 0000 1000 
  34. ---------- 与运算
  35. 0000 0000
  37. # 发现与运算结果为0，没有产生进位，所以结果就是上一个异或运算的结果  0000 1001

汇编语言

寄存器

内存

汇编指令

内存复制

堆栈指令

汇编写函数

堆栈传参

堆栈平衡