定点数的表示与运算

定点数编码

Tips：对于分式的定点数表示的小技巧.
如 x = 5/8，可以看作：

将 5 = 00101 右移（小数点左移） 3 = log(8) = log(2^3) 位，从而得到x = .10100
（假设机器字长是5）

注意，此处的右移并不是下面将要介绍的各种移位，而是我们通常使用的移动。
例如15.7=157/10就是将 157. 的小数点左移一位。

原码表示法

$[x]_{\text原}=\begin{cases}x&2^n\gt x\geq 0\\ 2^n-x=2^n+|x|&0\geq x \gt -2^n \end{cases}$

其中， $[x]_{\text 原}$ 是原码的机器数， $x$ 是真值， $n=0,1,2,...$
即，当 $x\gt0$ 时，原码就是其本身的二进制数，否则最高位置 1 ，其余不变。

注：真值为零的原码表示有正负两种，即 $[-0]_{\text 原}=\mathbf 0 0000$ ， $[+0]_{\text 原}=\mathbf 1 0000$

补码表示法

显然，对于原码表示，想要对数据进行加减运算是十分繁琐的，因此引入补码表示来解决这个问题，不仅如此，通过补码表示，数据的加减都能转换为纯加法计算。

纯小数补码定义：

$[x]_{\text补}=\begin{cases}x&1\gt x\geq 0\\ 2+x=2-|x|&0\geq x \gt -1 \end{cases}(\mod 2)$

纯整数补码定义：

$[x]_{\text补}=\begin{cases}0,x&2^n\gt x\geq 0\\ 2^{n+1}+x=2^{n+1}-|x|&0\geq x \gt -2^n \end{cases}(\mod 2^{n+1})$

其中，“ $0,x$ ”表示在真值 $x$ 前补0

当字长为 $n+1$ 时，整数补码能表示的范围是： $-2^n\leq x \leq 2^n-1$ ，比原码多了一个 $-2^n$ .

原因是补码中零的表示是唯一的，下面以字长为5进行示例
显然有 $[-0]_{\text 补}=[+0]_{\text 补}=\mathbf 0 0000$
而 $[+0]_{\text 原}=\mathbf 1 0000$ 中的 $\mathbf 1 0000$ 在补码中用来表示 $-2^n$ .

变形补码：

$[x]_{\text补}=\begin{cases}x&1\gt x\geq 0\\ 4+x=4-|x|&0\geq x \gt -1 \end{cases}(\mod 4)$

变形补码又称模4补码。上面给出的是 双符号位的补码小数定义。
其中，"00"表示正，"11"表示负，一般用在完成算术运算的ALU部件中。

模4补码具有模2补码的全部优点，且更容易检查加减运算中出现的溢出问题（这将在下面继续阐述）。
值得注意的是，模4补码仅需一个符号位，因为任意一个正确的数值其模4补码的两个符号位一定相同。
只有在把模4补码的数送往ALU进行加减运算时，才把符号位送到ALU的双符号位中，即 只在ALU中才采用双符号位。

补码的由来

想象现实中的时钟.

假如一个时钟比实际时间快了2小时指向10点，那么为了让它回到正确的时间点，即8点，我们需要人为地将指针往回拨2小时，即实现 $Times_{\text{时钟}}\leftarrow Times_{\text{时钟}}-2$ 。

那么如果这个时钟的指针只能顺时针走怎么办呢？
事实上，我们可以将指针按顺时针一直拨到下一个循环的8点（即20点）。也就是说，实现：
$Times_{\text{时钟}} \leftarrow Times_{\text{时钟}}+12-2$

显然，其中的12就是一个时钟的周期。

同样的思想可以引入到二进制当中，我们知道一个字长固定的机器码，在累加有限长的数值之后会陷入“循环”。例如8字长的机器码 11111111，加1之后就变成了 00000000.
也就是说，该机器码的“周期”是 $2^8$ 。

因此，如果我们要“往回拨00000001”，即表示 -00000001，也可以用类似的方法。

$\begin{aligned}-00000001=2^8-00000001&=(11111111+00000001)-00000001\\&=(11111111-00000001)+00000001)\\&=11111110+00000001\\&=11111111\end{aligned}$

上式中的等号并不是数值上的相等，仅作推导用。
值得注意的是，推导中倒数第二步的11111110就是00000001按位取反得到的。

虽然前面强调了等号不是数值相等，但是因为机器码的性质我们可以直接运用在计算中。即可以利用这种表示方法，以加法的方式计算减法。
记a，b均为正数，则有：

$\begin{aligned}&(a-b)\mod 2^n\\=&[(a-b)+2^n]\mod 2^n\\=&[a+(2^n-b)]\mod2^n\\=&(a+b_\text 补)\mod2^n\end{aligned}$

原补码转换

根据以上定义，可以轻易得出，对于正数的表示，补码和原码是一致的。
而对于负数，其转换方法为： 符号位不变，数值部分按位取反，末位+1
原码转补码和补码转原码都利用此方法，原因是补码的补码就是原码。

此外还有，B的补码转负B的补码方法：包括符号位在内，全部按位取反，末位+1

在上述转换中，出现了“按位取反”的步骤，其实将原码除符号位取反的这个中间步骤出现的编码就是反码，由于反码在计算机中不常用，仅作为中间步骤，这里不再赘述。

移码表示法

移码常用来表示浮点数的阶码。只能用来表示整数。

移码的定义如下：

$[x]_{\text 移}=2^n+x\quad(2^n \gt x \geq -2^n)$

其中， $n+1$ 是机器字长.

移码具有如下几个特点：

零的表示唯一
补码符号位取反就能得到移码
移码大小与真值大小对应，移码越大，真值就越大，反之亦然
移码全0时，对应真值最小值 $-2^n$ ，移码全1时，对应真值最大值 $2^n-1$

运算方法与电路

ALU中，运算器包括有加减乘除的四则运算，与或非异或等的逻辑运算，还有移位、求补等操作功能。
而ALU的核心部件则是 (并行)加法器 。

在设计多位加法器时，为了加快运算速度而采用了快速进位链，即对加法器的每位都生成两个信号：

进位信号 $g=X_iY_i$
进位传递信号 $p=X_i\oplus Y_i$

在串行进位的并行加法器中，影响加法器运算速度的因素有：

门电路的级延迟
元器件的速度
进位传递延迟（最主要）
各位加法器的速度不同

移位操作

算术移位：保留符号位

	码制	填补代码
正数	原码、补码、反码	0
负数	原码	0
	反码	1
	补码	左移补0
	补码	右移补1

补码左移的前提条件是其原最高有效位与原符号位相同，否则会发生溢出

逻辑移位：将操作数视为无符号数，补0
循环移位：通过是否带 进位标志位CF 进行分类

加减运算

在前面的描述中依然阐明了补码对于加减法的便利，此处给出直观了当的公式：

$\begin{aligned} \text{let}\quad [A]_{\text 补} &= X,[B]_{\text 补} = Y,\text{then}\\\\ [A+B]_{\text 补} &= [A]_{\text 补}+[B]_{\text 补} = X+Y\quad(\mod2^{n+1})\\ [A-B]_{\text 补} &= [A]_{\text 补}+[-B]_{\text 补} = X+(\overline Y+1)\quad(\mod2^{n+1}) \end{aligned}$

公式的定点小数证明

补码加减运算电路

补码加减运算部件
上图的加法器是带标志的加法器。显然本电路能够同时胜任无符号和有符号的整数加减运算。

对于带符号的整数 $x,y$ ，假设其补码分别为 $X,Y$ ，其运算结果由上图所示的电路产生。其中， $\text{Sub}$ 信号表示是做加法还是做减法，取1表示减法。

并且，由于 $[-Y]_\text 补 = \overline Y + 1$ ，而电路中仅仅出现了 $\overline Y$ ，所以，其实这里的 $\text{Sub}$ 也是 低位进位输入信息。

零标志 $\text{ZF}=1$ ，表示结果为0溢出
溢出标志 $\text{OF}=1$ ，表示运算结果溢出（只对有符号数的运算有意义）
符号标志 $\text{SF}$ ，表示结果的符号，也即是结果的最高位（只对有符号数的运算有意义）
进/借位标志 $\text{CF}$ ，表示无符号数运算时的进/借位情况，用以判断是否溢出。 $\text{CF}=\text{Sub}\oplus C_{out}$ . 即加法时， $C_{out}=1$ 表示溢出，减法时 $C_{out}=0$ 表示溢出（只对无符号数的运算有意义）

溢出判别

对于补码来说，当两个正（负）数相加得到的结果为负（正）；当一个负数减去一个正数得到的结果为正时，说明计算出现了溢出。

补码定点数的加减运算溢出判断拥有3个方法：

一位符号位：当两个操作数 $A,B$ 的符号 $A_s,B_s$ 相同，但是与运算结果的符号 $S_s$ 不同时，表明结果溢出。记溢出信号为 $V$ ，且当 $V=1$ 表示溢出，则有 $V$ 的逻辑表达式： $V=A_sB_s\overline S_s+\overline{A_sB_s}S_s$ .
双符号位：即前面所说的 模4补码/变形补码的运用。运算结果拥有两个符号位 $S_{s1},S_{s2}$ ，逻辑表达式为 $V=S_{s1}\oplus S_{s2}$ .此外，有：
- $S_{s1}S_{s2}=00$ ，结果为正，无溢出；
- $S_{s1}S_{s2}=01$ ，结果正溢出；
- $S_{s1}S_{s2}=10$ ，结果负溢出；
- $S_{s1}S_{s2}=11$ ，结果为负，无溢出.
一位符号位+进位情况判断：当符号位的进位 $C_s$ 与最高数位的进位 $C_1$ 不同时，说明溢出，即 $V=C_s \oplus C_1$

♾️做题技巧：已知十进制数或者容易求出十进制数时，我们可以直接将其十进制数进行运算，通过判断十进制运算结果是否在对应字长所能表达的范围内来判断是否溢出。

乘法运算

回忆算术中，列竖式计算乘法的过程（此处假设满2进1）：

$\begin{aligned} &0.1011\\ \times &0.1101\\ \hline &0.1011\\ &\!\!\! 0.0000\\ &\!\!\!\!\!\! 0.1011\\ &\!\!\!\!\!\!\!\!\! 0.1011\\ &\!\!\!\!\!\!\!\!\!\!\!\! 0.0000\\ \hline&\!\!\!\!\!\!\!\!\!\!\!\!0.10001111 \end{aligned}$

可以发现，我们是按照乘数从低位到高位的数值进行判断，从而累计求和，期间还需要将“加数”进行左移操作的一系列步骤进行乘法运算的。
类似地，我们可以反过来通过按照乘数从低位到高位，此外伴随着部分积（即计算过程中我们一直在累加的中间变量）进行右移操作来得到同样的结果。

于是就衍生出了如下算法……

原码一位乘法

设 $[x]_{\text 原}=x_s.x_1x_2\dots x_n,[y]_{\text 原}=y_s.y_1y_2\dots y_n$ .则：

先对符号位进行运算 $x_s\oplus y_s$ ，然后将 $x,y$ 剩下的二进制码作为无符号数进行处理。

记部分积为 $Ans$ ，长度与被乘数一致为 $n+1$ 。从 $y_n$ 开始，初始化 $Ans=0$ ，然后依次循环执行：

$Ans\leftarrow Ans+y_i|x|$ ;
$Ans \quad\text{SAR}$
重复1和2直到 $y_1$ 结束(一共n次）

其中，SAR（逻辑右移）：shift arithmetic right

考虑到运算时可能出现绝对值大于1的情况，因此部分积和被乘数都取 双符号位

下面给出一个示例：设机器字长为5位，其中一位是符号位。且 $x=-0.1101,y=+0.1011$ ，利用原码一位乘法求 $P=x·y$ .
原码一位乘法示例

补码一位乘法（ Booth 算法）

下面先简要阐述Booth算法的基本流程：

设 $[x]_{\text 补}=x_s.x_1x_2\dots x_n,[y]_{\text 补}=y_s.y_1y_2\dots y_n$ ，将符号位参与计算，运算数以补码表示且被乘数与部分积都取双符号位。

记部分积初值 $Ans=0$
乘数末位增加附加位 $y_{n+1}$ ，初值置1
根据 $(y_n,y_{n+1})$ 的取值，按下表执行

$y_n$	$y_{n+1}$	操作
0	0	$Ans\;SAR$
0	1	$Ans\leftarrow Ans+[X]_{\text 补},Ans\;SAR$
1	0	$Ans\leftarrow Ans+[-X]_{\text 补},Ans\;SAR$
1	1	$Ans\;SAR$

循环执行第3步 $n+1$ 次，此时得到了 $n+1$ 次对 $Ans$ 的累加，并且最后一次不右移，此时执行了 $n$ 次右移。

下面给出一个示例：设机器字长为5位，其中一位是符号位。且 $x=-0.1101,y=+0.1011$ ，利用Booth算法求 $P=x·y$ .
Booth算法示例

拓展|Booth算法原理

由于乘法计算的本质就是加法的累加，因此当乘数的二进制代码中“含1量”过高时，必然会出现大量频繁的加法计算，但事实上这并不是必要的。

回忆小学时，我们曾经做过如下的简便计算： $9\times 99=9\times (100-1)=900-9=891$
这就是一种化简方法，在二进制中同样有类似的化繁为简的妙用，例如：
$001111100=010000-10$ . 注意，这里不能看成是用010000减去10，而应该看成二进制的第二位取-1（负1）。

显然如果用010000-10作为乘数的话，比起前者（001111100）机器需要做5次累加来说，计算量减小到了2次。但是第一次是做减法而不是加法，因此对于补码来说才更容易实现。

那么问题又来了，我们该如何“一眼看出”001111100可以化为010000-10呢？

我们记正乘数 $Y=(y_s.y_1y_2\cdots y_n)_2$ ，所以 $y_s=0$ ，因此：

$\begin{aligned}Y&=y_12^{-1}+y_22^{-2}+\cdots +y_{n-1}2^{-(n-1)}+y_n2^{-n}\\2Y&=y_12^0+y_22^{-1}+y_32^{-2}+\cdots+y_n2^{-(n-1)}\\2Y-Y=Y&=y_12^0+(y_2-y_1)2^{-1}+\cdots+(y_n-y_{n-1})2^{-(n-1)}+(0-y_n)2^{-n}\end{aligned}$

取 $y_{n+1}=y_s=0$ , 则第一项和最后一项就分别为 $(y_s-y_1)2^0,(y_{n+1}-y_n)2^{-n}$ .

由于 $y_i\in \{0,1\}$ ，所以有：

当 $y_{i+1}=y_i$ 时，第 $i$ 项取0
当 $y_{i+1}\gt y_i$ 时，第 $i$ 项取1
当 $y_{i+1}\lt y_i$ 时，第 $i$ 项取-1

此时我们再来回看 Booth算法的操作步骤表，就显得十分简单了.

$y_n$	$y_{n+1}$	操作
0	0	+0，右移一位
0	1	+[x]补，右移一位
1	0	+[-x]补，右移一位
1	1	+0，右移一位

除法运算

回忆算术中，列竖式计算除法的过程：

$\begin{aligned} & \quad\;0.1101 \\ 0.1101 & \overline{)\;\;\;0.10110\quad\quad } \\ & \underline{-\;\;0.01101\quad}\quad\quad\ \\ & \quad\;0.010010 \\ & \underline{-\;\;0.001101\quad} \\ & \quad\;0.00010100\\ & \underline{-\;\;0.00001101}\\ & \quad\;0.00000111 \end{aligned}$

手算除法时，我们是先判断被除数能不能被除数减，如果能则商1，否则商0；然后我们将除数补0右移，再和余数进行比较，如此往复直到余数为0或商达到指定的位数要求。

同样的逻辑，事实上也可以用机器进行实现。

由于机器并不会像人类一样直接判断大小，因此需要先作减法，通过对余数判断正负来决定此时的商。若余数为正，则商1，反之亦然。
此外，当发现余数为负时，为了下一步计算，事实上应该恢复上一次的余数，以便再继续往下运算。而要恢复原来的余数，只要当前的余数加上除数即可，这种方法称为恢复余数法。
但由于要恢复余数，使除法进行过程的步数不固定，因此控制比较复杂。实际中常用不恢复余数法，又称加减交替法。其特点是运算过程中如出现不够减，则不必恢复余数，根据余数符号，可以继续往下运算，因此步数固定，控制简单。

原码加减交替除法

设被除数和除数分别为 $[x]_{\text 原}=x_s.x_1x_2\dots x_n,[y]_{\text 原}=y_s.y_1y_2\dots y_n$ ，将符号位单独计算，显然商的符号 $Q_s=x_s\oplus y_s$ ，商的数值 $|Q|=|x|/|y|$ .

不恢复余数法的规则如下：

被除数(余数)减去除数作为此次计算的余数，即 $|x|-|y|=|x|+[-|y|]_{\text 补}$
若余数为正，商上1，然后余数和商都左移一位，再将余数减去除数
若余数为负，商上0，然后余数和商都左移一位，再将余数加上除数
重复上述步骤，直到完成运算（重复了 $n+1$ 次）。若第 $n+1$ 步得到的余数为负，将其加上 $|y|$ 才能得到正确的余数（恢复余数），此时余数和被除数是同号的

下面给出一个示例：设机器字长为5位，其中一位是符号位。且 $x=0.1011,y=0.1101$ ，利用原码不恢复余数法求 $Q=x/y$ .
加减交替法示例

注意，因为一共左移了4次，所以余数应该是最后得到的余数再乘以 $2^{-4}$

加减交替法的简单证明

假设第 $i-1$ 次求商所得余数为 $R_{i-1}\geq 0$ ，根据算法，本次商上1，然后将余数左移一位，得到 $2R_{i-1}$
第 $i$ 次求商，此时余数为 $R_i=2R_{i-1}-|y|$ ，则：
若 $R_i \geq 0$ ，商上1，第 $i+1$ 次求商时，余数 $R_{i+1}=2R_i-|y|$
若 $R_i \lt 0$ $R_{i} < 0$ ，商上0，此时余数为负，那么：
- 如果选择 恢复余数，要将 $R_i$ 加上除数 $|y|$ 实现恢复，然后再左移进行下一次计算。
  所以第 $i+1$ 次求商时，余数 $R_{i+1}=2(R_i+|y|)-|y|=2R_i+|y|$
- 如果选择 不恢复余数，而是根据不恢复余数法，直接对余数左移，然后再在 $i+1$ 次时加上 $|y|$
  显然，此时的余数 $R_{i+1}=2R_i+|y|$

通过上述推导不难发现，无论是恢复余数还是不恢复余数只做加法，结果都不变。因此加减交替法是切实可行的。
最主要的是，加减交替法固定了机器每一步的操作，所以使得运行上更加可控

补码加减交替法

补码的核心思想与原码是一致的，并且显而易见地，原码的除法实现中也借助了补码来实现运算。与原码除法有区别的是，补码除法还需要解决以下几个问题：

求商符的确定；
如何确定上商值和余数值；
商要如何校正

对于第一个问题其实很好解决。我们规定被除数和除数满足 $0<|x|<|y|$ ，则：
在第一步试减时，

若 $x$ 和 $y$ 同号：因为不够减，即 $R_0$ 与 $y$ 异号，所以商上0
若 $x$ 和 $y$ 异号：因为不够减，即 $R_0$ 与 $y$ 同号，所以商上1
因此，第一次试减的商结果就为我们确定了商的符号位，即商通过一次试减就自动完成了。

结论就是：同号商1，异号商0。

对于第二个问题，先说明一个现象或者说定理：

当a，b同号时：
- 如果|a|>|b|，那么，a-b一定与a、b都同号；
- 如果|a|<|b|，那么，a-b一定与a、b都异号。
当a，b异号时：
- a-b一定与a同号与b异号，无法判断|a|和|b|的大小关系。
- 如果|a|>|b|，那么，a+b一定与a同号与b异号；
- 如果|a|<|b|，那么，a+b一定与a异号与b同号。

由于加减交替法要求余数不断左移，因此在a做被除数，b做除数时，我们无法根据a的符号进行辨别。因此，我们以除数b的符号作为依据。
即： $x,y$ 同号，并且能商1时(即 $|y|/|x|\geq 1$ 时)， $([x]_\text 补+[-y]_\text 补)$ 一定与 $y$ 同号，如果异号则只能商0；相反， $x,y$ 异号时只有 $([x]_\text 补+[y]_\text 补)$ 与 $y$ 异号才能商1，否则只能商0.

因为同号和异号的判断依据不同，为了简便计算这里统一为：
余(数)除(数)同号上商1，余除异号上商0

之所以能这样统一，是源于补码的特殊性。
这里我们延续第一个问题（商符号的确立）进行简要解释：
因为 $x,y$ 同号时，商的符号位是0，并且之后的上商计算其实是和原码是一样的；
而在 $x,y$ 异号时，商的符号位是1，按照上面的统一规则的话，其实我们后面上的商都是反码。

对于第三个问题，我们需要回看s上一个问题最终的结论，即异号时是 反码上商.
显然反码和补码只相差最后1位的确定，并且这1位我们只能估计。而对于小数来说，其实这一位的误差仅仅只是 $2^{-n}$ ，因此是可以在一定精度范围内忽略不计的。

目前，补码除法的规则是 商末置1法，即取最后一位为1即可。

阐明了补码除法出现的问题以及如何解决之后，我们得到了补码除法的具体计算步骤。
算法流程如下：

设被除数和除数分别为 $[x]_{\text 补}=x_s.x_1x_2\dots x_n,[y]_{\text 补}=y_s.y_1y_2\dots y_n$ 。
符号位参与计算，除数被除数，商和余数均用补码表示。
如果 $|y|=0$ 直接结束运算。
若 $x,y$ 同号，则 $([x]_\text 补+[-y]_\text 补)$ 作为余数
若 $x,y$ 异号，则 $([x]_\text 补+[y]_\text 补)$ 作为余数
若余数与除数同号，商上1，然后余数和商都左移一位，再将余数减去除数
若余数与除数异号，商上0，然后余数和商都左移一位，再将余数加上除数
重复6,7步 $n$ 次，商的末位置1

下面给出一个示例：设 $x=0.1000,y=-0.1011$ ，利用补码加减交替法求 $[x/y]_\text 补$
补码除法示例

注意，因为一共左移了4次，所以余数应该是最后得到的余数再乘以 $2^{-4}$

由上述两个除法的例子可见， $n$ 位定点数的除法运算实际上是用 $2n$ 位的数除以一个 $n$ 位的数，从而得到 $n$ 位的商。
因此需要对被除数进行扩展补0操作。定点正小数在被除数低位补 $n$ 个0； $n$ 位无符号数或者定点正整数在被除数高位补 $n$ 个0.

C语言类型转换

对于C语言，通常有：

类型	16位	32 位	64位
`char`	1	1	1
`short int`	2	2	2
`int`	2	4	4
`unsigned int`	2	4	4
`float`	4	4	4
`double`	8	8	8
`long`	4	4	8
`long long`	8	8	8
`unsigned long`	4	4	8

有符号和无符号

int main(void){
	short x = -4321;
	unsigned short y = (unsigned short)x;
	printf("x = %d, y = %u\n",x,y);
}
// x = -4321, y = 61215
// 1110111100011111

二进制数值相同，只是解释方式发生了变化

字长不同的整数

int main(void){
	int x = 165537, u = -34991; // int 型占用 4B
	short y = (short)x, v = (short)u; // short 型占用 2B
	printf("x = %d, y = %d\n",x,y);
	printf("u = %d, v = %d\n",u,v);
}
// x = 165537, y = -34991
// u = -34991, v = 30545
// (x) 0x000286a1; (y) 0x86a1
// (u) 0xffff7751; (v) 0x7751

大字长转小字长，高位直接截断

int main(void){
	short x = -4321;
	int y = x;
	unsigned short u = (unsigned short)x;
	unsigned int v = u;
	printf("x = %d, y = %d\n",x,y);
	printf("u = %d, v = %d\n",u,v);
}
// x = -4321, y = -4321
// u = 61215, v = 61215
// (x) 0xef1f; (y) 0xffffef1f
// (u) 0xef1f; (v) 0x0000ef1f

小字长转大字长，高位符号扩展

数据存储与排列

大小端方式

在存储数据时，通常用 LSB 最低有效字节和 MSB 最高有效字节来表示数的低位和高位。

现代计算机基本上都采用 字节编址 ，即每个地址编号存放一个字节。
而字节的排序方式就各有不同了。通常我们按字节在连续字节序列中的排列顺序进行分类，有：

大端方式| Big Endian
小端方式|Little Endian

以 int 类型的 0x12345678 为例，它占用 4 个字节，假设从地址 0x4000 开始存放，那么：

小端模式（Little-endian）

内存地址	0x4000	0x4001	0x4002	0x4003
存放内容	0x78	0x56	0x34	0x12

大端方式（Big-endian）

内存地址	0x4000	0x4001	0x4002	0x4003
存放内容	0x12	0x34	0x56	0x78

我们的 PC 机上使用的是 X86 结构的 CPU，它是小端模式；
51 单片机是大端模式；
很多 ARM、DSP 也是小端模式（部分 ARM 处理器还可以由硬件来选择是大端模式还是小端模式）。

借助共用体，我们可以检测 CPU 是大端模式还是小端模式：

#include <stdio.h>
int main(void){
	// 建立共用体data
	union{
		int n; // 4B
		char ch; // 1B
	} data;

	data.n = 0x00000001; //也可以直接写作 data.n = 1;
	
	if(data.ch == 1){
		printf("Little-endian\n");
	}else{
		printf("Big-endian\n");
	}

	return 0;
}

共用体各个成员共用一段内存
0x01 是数据的低位.
如果 0x01 被存储在 data 的低字节，就是小端模式，即此时 data.ch 的值也是 0x01。
如果 0x01 被存储在 data 的高字节，就是大端模式，此时 data.ch 的值就是 0x00

边界对齐存储

在计算机的机器字长固定之后，最简单的数据存储方式就是按顺序依次存储。
而为了节约存储空间，最容易想到的存储方式就是将数据紧密地排列起来，如下图所示：
边界不对齐方式

我们知道，如果像上图一样填充的话，计算机在根据地址访问数据 x 时，需要进行 3 次访存，并且再对高低字节的位置进行调整合并，这极大地影响了指令的执行效率。

因此，计算机中常常使用如下的边界对齐方式对数据进行存储：

图中空白的部分是留空的部分，因此边界对齐存储会丢失一部分存储空间。而由于地址都是数据字节的整数倍，所以对于 字节、半字和字 来说，均可以一次访存取出，这提高了运行效率。

我们给出对齐存储的规则如下：

编译器按成员列表的顺序为每个成员分配内存
结构的起始存储位置为该结构中边界对齐要求最严格的数据类型所要求的位置
第一个成员存放在偏移量为0的位置；
接下来的各成员存放在偏移量为该成员的类型所占字节数的整数倍的位置；
结构体大小为该结构体中占用空间最大的成员的所占字节数的整数倍

真题考点

此处以 2012年408统考真题 为例进行讲解

某计算机存储器按字节编址，采用小端方式存放数据，假定编译器规定int和short型长度分别为32位和16位，并且数据按边界对齐存储，其C语言程序段如下：

struct {
	int a;
	char b;
	short c; 
}record;

record.a = 273;

若record变量的首地址为0xC008，则地址0xC008中的内容及record.c的地址分别为（）

A . 0x00， 0xC00D

B . 0x00 ，0xC00E

C . 0x11 ，0xC00D

D . 0x11 ，0xC00E

答案

首先，record的首地址存放的即是record.a的内容
而 a=273=0x00000111，小端存储，先存放小的那一端，所以存放的是0x11。

然后，因为是边界对齐，即对于存放某长度为m字节的数据，存放地址需在m字节的整数倍存放，结构体整体的大小是最大成员长度的整数倍。
因此有：

地址	`0xC008`	`0xC009`	`0xC00A`	`0xC00B`
内容	`record.a`(`0x11`)	`record.a`(`0x01`)	`record.a`(`0x00`)	`record.a`(`0x00`)

地址	`0xC00C`	`0xC00D`	`0xC00E`	`0xC00F`
内容	`record.b`	-	`record.c`	`record.c`

记首地址0xC008处为偏移量为0的单元，则0xC00E处的偏移量是6，是sizeof(short)==2的整数倍。

浮点数的表示与运算

浮点数表示法是指以适当的形式将比例因子表示在数据中，让小数点的位置根据需要而浮动。
我们可以回忆小学二年级就学过的 科学记数法 对大数的表示，例如：
$19971400000000=1.99714×10^{13}$ 。
计算机表达10的幂是一般是用E或e，也就是1.99714E13=19971400000000。

那么类似地，对于二进制来说，我们可以将数据表示成：

$N=r^E\times M$

式中， $r$ ——浮点数的基数，通常取2、4、16等。
$E$ ——阶码，也就是指数，通常用二进制定点整数表示。
$M$ ——尾数，通常用二进制定点小数表示。

可见，尾数的位数决定着浮点数的有效位数，有效位数越多，数据的精度就越高。

规格化

科学记数法中， $134\times 10^3$ 是不规范的，需要将其改为 $1.34\times 10^5$

类似地，浮点数的规格化就是通过一系列操作使得浮点数的尾数最高位为一个有效值。目的显然是为了尽可能地保留有效数字的位数，从而增加数据的表示精度。

上面提到的一系列操作，这里有两种：

左规：当尾数的最高位不是有效位时，需要将尾数左移（就是将小数点右移），直到尾数变成规格化形式为止。该过程同时还伴随着阶码的减小，如果基数是2，则尾数每左移一位，阶码就需要减1。左规可能需要进行多次。
右规：对浮点数进行运算时，如果尾数出现有效进位，使得结果不再是小数时，需要将尾数右移（就是将小数点左移），然后阶码加1（基数是2的情况）。对于二进制进位来说，进位结果肯定不会超过1位，因此右规只需进行一次。

Tips: 当基数是4时，规格化的尾数最高两位不全为0

溢出判断

当进行浮点数运算时，运算结果大于最大正数时称为 正上溢；结果小于绝对值最大的负数时称为 负上溢。二者统称为上溢.
数据一旦产生上溢，计算机必须中断运算操作，进行溢出处理。

当进行浮点数运算时，运算结果在0到最小正数之间时称为 正下溢；结果在0到绝对值最小的负数之间时称为 负下溢。二者统称为下溢.
数据下溢时，浮点数值趋于零，计算机将其作为机器数0进行处理。

IEEE 754 标准

根据 IEEE 754 标准，常用浮点数的格式不再是前文介绍的 $N=r^E\times M$ ，而是更为标准的：

$N=(-1)^S\times 1.M\times r^E$

式中， $r$ ——基数，隐含为2。
$E$ ——阶码，要求用二进制移码表示。
$1.M$ ——尾数，通常用二进制 隐藏位策略的原码（定点小数） 表示。
$S$ ——数符，0表示正数，1表示负数。

编码格式

类型	数符	阶码	尾数数值	总位数	偏置(16进制)	偏置(10进制)
短浮点数	1	8	23	32	7FH	127
长浮点数	1	11	52	64	3FFH	1023
临时浮点数	1	15	64	80	3FFFH	16383

注：上表的数符、阶码、尾数从左到右的出现顺序，即是计算机中存储浮点数的划分顺序.

短浮点数即是单精度、float类型
长浮点数即是双精度、double类型

特殊值和偏置值

在 IEEE 754 标准中，除了上述的规格化表示外，还有一些特殊值的表示方法，具体见下表。

值	阶码	尾数	描述
零	$0$	$0$	表示: $±0$ （正负取决于符号位）
非规格化	$0$	非 $0$	有效数字的整数部分为固定数值0
规格化	$[1,2^n−2]$	任意	指数偏置值为 $2^{n-1}−1$
无穷	$2^n-1$	$0$	阶码是 $2^n-1$ （即阶码位全是1），表示: $±\infty$ （正负取决于符号位）
NaN	$2^n-1$	非 $0$	表示:不是一个数（`NaN`）

非规格化形式用于表示非常接近0的数，此时的实际尾数区别于规格化的 $1.M$ 应该是 $0.M$
引入“无穷”的概念是为了使得在计算出现异常时，程序能够继续运行

阶码在IEE754标准中用移码表示，其定义是：

$\begin{aligned} \;[x]_{\text 移}&=2^{n-1}+x\\ x&=[x]_{\text 移}-2^{n-1} \end{aligned}$

因此，想要通过移码计算出实际阶数，我们需要将移码减去偏置值。

而通过上面的表格，我们注意到，阶码在IEEE754标准下，全1和全0的情况下都有着特殊的表示含义。
以float型数据为例，IEE754标准为其分配了8位作为阶码，因此用移码表示的话，其可选值为：00000000 ~11111111，即 0~ 255，去除表示0和无穷大的两种情况，则为 1~254
如果偏置值取 $2^{8-1}=128$ ，则阶码的真值为 -127~+126
如果偏置值取127，则阶码的真值为 -126~+127

权衡之下，我们更希望能表示 $2^{127}$ 数量级的大数据，因此和真正的移码相比，浮点数的移码的偏置值是不同的。

最终定义：float型的偏置值是127，double型的偏置值是1023

💦结合移码与补码的关系：补码的符号位取反就是移码。
我们可以进一步得出下面的快速解题技巧：

当移码符号位是1时，说明阶数为正，根据移码与补码的关系，可将除符号位的移码直接转换为十进制数，之后再将结果+1得到正确的阶数。
当移码符号位是0时，说明阶数为负，根据移码与补码的关系，可将除符号位的移码按位取反后，直接转换为十进制数，之后再带上符号，结果即为正确的阶数。

浮点数的运算

浮点数的运算特点是阶码运算和尾数运算分开进行。

对阶按照 小阶向大阶看齐原则，将阶码小的尾数右移一位，阶数+1。
- 其中右移会舍入低位的有效位，影响精度。
尾数求和 按照定点小数的加减规则直接对尾数进行计算。结果进行规格化。
溢出判断 运算结果是否溢出主要是看结果的指数是否发生上溢。一般地，如果带双符号位进行计算时，阶码的符号位出现 01 则表示发生上溢，10 则表示发生下溢。

舍入

在对阶和右规的过程中，可能会将尾数的低位丢失，从而引起误差，影响精度。

舍入方式的原则：

尽量使误差范围对称，使得平均误差为0.即有舍有入，防止误差积累
方法要简单，以加快速度

常见的舍入方法：

0舍1入法 类似于十进制的 四舍五入法。如果将被丢弃的值是0就直接舍弃；如果是1则舍弃后在尾数末位+1。这样做可能会使得尾数产生溢出，此时需要继续右规。
恒置1法 无论将被丢弃的值是1还是0.都将右移后的尾数末位数值置1。
截断法 直接截取所需位数，丢弃后面的所以位。

实例演示

为了加深的对浮点数的加减运算，此处暂举一例，并用直观算法和机器算法两种方式进行讲解。
例

C语言的浮点数

C 语言中的 float和double分别对应 IEEE 754 单精度浮点数和双精度浮点数。
long double类型对应与扩展的双精度浮点数，但其长度和格式与编译器和处理器类型有关。

强制转换

char -> int -> long -> double， float -> double
以上两种 C 程序中的强制转换，从前到后范围和精度依次增大，转换过程没有损失。
int -> float
由于float的尾数包括隐藏位一共只有24位，因此如果int数据超过24位，即其24~31位非0的话，就会在转换过程中舍入低位，影响精度。
float/double -> int
转换时，因为int只表示整数，所以会将小数部分直接截断。另外由于int表示范围更小，所以大数转换时可能发生溢出。
double -> float
基本同上。

混合运算时，遵循 “类型提升”原则。

Q: 位数相同的浮点数比定点数可表示的数据个数多吗？

A: 否。 $n$ 位编码只能表示 $2^n$ 个数。（当然存在有一个值有多个编码对应的情况，所以个数会有少量差异）

二进制世界的数据运算守则