float/double在内存中的格式，分享下IEEE 754规则

1 今天有空和大家分享下IEEE 754标准，同时解释下我们所谓的”精度“表达

我会讲的很细，因为我觉得很多人都没有细究，哈哈。

我们先看一个例子，下面是十进制的 -10.25 在内存中的布局，当然这是IEEE754标准

什么是IEEE 754?
任意一个浮点数f可以表示为 $f=(-1{)}^s\ast m\ast b^e$。

通过公式和图的对比，可以知道

1. s = 1（符号位，为1表示负数，为0表示正数）
2. b = 2(基底，一般就是2，当然这里不讨论10进制哈)
3. e = 3
4. $m=1.1001_2$

这个公式只是数学表达，怎么知道内存的布局呢？

2 内存中是如何布局的呢？

首先，必须肯定的几个预备知识

1. 32位浮点数的移码E为8位，尾数T为23位，符号S位1位，因此E的取值范围是[0,255]
2. 64位浮点数的移码E为11位，尾数T为52位，符号S位1位,因此E的取值范围是[0,2047]
3. IEEE 754标准规定，在计算机内部保存尾数m时，默认该数的第一位总是1，这样的二进制浮点数称为规范浮点数（normalized float number），简称规范数。由于规范数的尾数m的第一位总是1，实现时可以舍去，只保存后面的小数部分，因此规范数的尾数m满足0.5≤m＜1。(也就是上表的T)

第一步，计算T
从上面知道，$m=1.1001_2$，取尾数$1001_2$，由于32位float的T是23位，需要补19个0
32位 $T=10010000000000000000000_2$
64位double的T是52位，需要补48个0
64位 $T=1001000000000000000000000000000000000000000000000000_2$
第二步，计算E
需要简单的还算下，IEEE 754的另一个规则
上面提到，32位浮点数的E取值范围是[0,255]，这是IEEE 754硬性规定，但是指数上的e是可以是负数的，因此真正的移码E是加上一个偏移的结果。
4. 32位浮点数， E = e + 127, 正如这里的E = 3+127 =130 = $10000010_2$
5. 64位浮点数， E = e + 1023, 正如这里的E = 3+1023 =1026= $10000000010_2$

因此,32位浮点数-10.25内存表示是： $-10.25_{10}=1_{S}10000010_{S}10010000000000000000000_T$
因此,64位浮点数-10.25内存表示是： $-10.25_{10}=1_{S}10000000010_{S}1001000000000000000000000000000000000000000000000000_T$

3 验证结论

#include <bits/stdc++.h>
using namespace std;

void toReadable(const string& s)
{
    if (s.size() == 32)
    {
        cout << " S = " << s.substr(0, 1); // 符号位
        cout << " E = " << s.substr(1, 8); // E = 8
        cout << " T = " << s.substr(9);    // T = 23
    }
    else if (s.size() == 64)
    {
        cout << " S = " << s.substr(0, 1);  // 符号位
        cout << " E = " << s.substr(1, 11); // E = 11
        cout << " T = " << s.substr(12);    // T = 52
    }
}

int main(int argc, char *argv[])
{
    float f = -12.5;

    // 将存储浮点数的四个字节解释为一个无符号整数
    unsigned int *ui = (unsigned int *)(&f);

    // 将无符号整数表示成二进制形式并输出，该二进制编码即为浮点数在内存中的编码
    bitset<32> uis(*ui);
    toReadable(uis.to_string()); // 将二进制转成字符串 to_string
    cout << endl;

    return 0;
}

// Output,和我们预期结果一致
 S = 1 E = 10000010 T = 10010000000000000000000

4 一些解释

4.1 疑问1：为什么把32位浮点数转成unsigned int*呢？

答案很简单，因为这和float是32位，而unsigned int: 4B, 0 ~ 4294967295，也就是不管32位浮点数在内存是什么，unsigned int（4B）都能装下。
64位用什么呢？
unsigned long int: 8B, 0 ~ 18446744073709551615，8字节最大值都能装下，还怕谁？

4.2 疑问2：所谓的float有8位有效数字，怎么算的？

根据IEEE 754标准，float数据类型有23位（二进制）尾数，如果保存的是规范数，即小数点的左侧始终为1，那么可以节省1位存储空间，相当于使用23位的存储空间保存24位的尾数。
我们算一个极限，按照整数算
$2^{24}-1=16777215$
数一下，一共有8位，也就是float有效数字是8位，而且是整数+小数，一行要注意这点！！！
举例，下面都是无法准确存取的，就32位为例

1. f = 12345678.1，总共位数是9位，计算机内部可能存储为12345678.000000
2. f = 1234567.81，总共位数是9位，计算机内部可能存储为1234567.750000（第八位不对）
3. f = 1234567.9，总共位数是8位，但是计算机内部可能存储为1234567.875000（第八位不对）

你会发现，不是8位精度吗？为什么第8位不对呢，因为8位在整数下考虑，实际上，32位浮点前7位绝大部分是一样的，第八位整数可以，小数float第八位有偏差。

1. f = 123456.1，总共位数是7位，计算机内部可能存储为123456.101562
   可以看出，存入7位，在内存中确实保证了前7位不变，后面的是无法保证的哈

最后，给出理论公式
float数据类型的实际表示精度为$lo{g}_{10}(2^{24}－1)＋1\approx 8$位十进制数

double同理
$2^{53}-1=9,007,199,254,740,991$ ，也就是16位
double数据类型的实际表示精度为$lo{g}_{10}(2^{53}－1)＋1\approx 16$位十进制数

4.3 疑问3：所谓的float的小数位数是6位，怎么算的？

当使用float数据类型保存小数时，由于其尾数最大为23位，而$2^{-23}＝0.00000011920928955078125$，则对于小于0.0000001的小数部分，float数据类型无法精确表示，因此float数据类型在表示小数时的精度最多为7位

但是，绝大部分机器只能保证6位，因为考虑的最小极限值，实际上还有整数的0，一共7位。

1. f = 0.0000011， 一共8位，是一条规则临界状态，第二条规则是小数后6位。计算机内部可能存储为0.000001。最后一个1直接截断

下面是OK的
2. f = 0.123456， 一共7位，小数后6位， 准确存储0.123456

double小数位数
$2^{-52}＝2.2204460492503130808472633361816e^{-16}$
哈哈，一般都没有考虑double的最小精度问题，实在太小了，但是受16位有效数字限制
举个例，double真的不用担心
3. f = 0.123456789123456789， 计算机内部可能存储为0.12345678912345678380

5 总结

相比double,float计算速度更快，耗用的资源更少，如果对这方面有要求的可以使用32位float,

保守的话，
32位float,最多7位有效数字，6位小数位数，不要挑战极限，因为你会失望的。嘿嘿，double的态度无所谓