上一篇文章（链接: link）介绍了整型在内存中是如何存储的。整型在内存中存储的是二进制补码，对于有符号整型，最高位存储符号位，其余都为有效数字位；而对于无符号整型，存储的都是有效数字位。
前言
1.清楚什么是浮点数。
常见的浮点数：
3.14159
1E10
浮点数家族包括： float、double、long double 类型。
浮点数表示的范围：float.h中定义
2.掌握浮点数是怎样存储于计算机的。
3.解决以下问题。
为什么 0x00000009 还原成浮点数，打印就成了 0.000000 ？
提示：以下是本篇文章正文内容，下面案例可供参考
一、浮点数存储规则
根据国际标准IEEE（电气和电子工程协会） 754，任意一个二进制浮点数V可以表示成
V = (-1)^S * M * 2^E, 其中：
- (-1)^S表示符号位，当S=0，V为正数；当S=1，V为负数。
- M表示有效数字，大于等于1，小于2。
- 2^E表示指数位。
举例：将十进制5.5化为二进制形式，并求出S,M,E.
5.5可以分成5和0.5来看：
5对应的二进制是0101，采用8421BCD码可以很快地求出十进制和二进制之间的转化，如：0101对应着8421，对应位相乘再相加就等于5.
0.5对应二进制小数点后面一位，对应2^(-1),也就是十进制0.5.
因此二进制为：101.1 = 1.011 * 2^2 = (-1)^0 * 1.011 * 2^2
S=0 M=1.011 E=2
但并不是所有的小数都能够准确的表达出来的，存在浮点数存储的精度问题：
如：3.14
二进制表达：11.001…… 小数点后三位的1代表1*2^(-3)=0.125
以上讨论到的S, M, E在计算机中存储是有一定的规律的：
IEEE 754规定：
对于32位的浮点数，最高的1位是符号位S，接着的8位是指数E，剩下的23位为有效数字M，如下图所示：
对于64位的浮点数，最高的1位是符号位S，接着的11位是指数E，剩下的52位为有效数字M，如下图所示：
IEEE 754对有效数字M和指数E的存储，还有一些特别规定。
对于有效数字M的存储
前面说过， 1≤M<2 ，也就是说，M可以写成 1.xxxxxx 的形式，其中xxxxxx表示小数部分。
IEEE 754规定，在计算机内部保存M时，默认这个数的第一位总是1，因此可以被舍去，只保存后面的xxxxxx部分。比如保存1.01的时候，只保存01，等到读取的时候，再把第一位的1加上去。这样做的目的，是节省1位有效数字。
以32位浮点数为例，留给M只有23位，将第一位的1舍去以后，等于可以保存24位有效数字。
至于指数E的存储，情况就比较复杂。
首先，E为一个无符号整数（unsigned int）
这意味着，如果E为8位，它的取值范围为0 ~ 255；如果E为11位，它的取值范围为0 ~ 2047。但是，我们知道，科学计数法中的E是可以出现负数的，所以IEEE 754规定，存入内存时E的真实值无论是正数还是负数，都必须再加上一个中间数。
对于8位的E，这个中间数是127；对于11位的E，这个中间数是1023。比如，2^10的E是10，所以保存成32位浮点数时，必须保存成10+127=137，即10001001。
举例说明：
十进制的0.5化为二进制是0.1
它可以表示成(-1)^0 * 1.0 * 2^(-1)
其中:S = 0
M = 1.0
E = -1
E存储在32位机器中存的是E + 127 = 126
E存储在64位机器中存的是E + 1023= 1022
再如以下代码：
int main()
{
float f = 5.5;
return 0;
}
通过调试内存发现f在内存中由低地址向高地址的存储是如下图这样的：
分析：
十进制5.5 --> 二进制101.1 = (-1)^0 * 1.011 * 2^2
其中:S = 0 M = 1.011 E = 2
在32位内存中的存储：0 10000001 01100000000000000000000//这里的E = E + 127,对应二进制10000001
//有效位存储M的小数位011，整数位1不需要存，后面的空位补0
将以上二进制化为16进制：0100 0000 1011 0000 0000 0000 0000 0000
--> 0x40 B0 00 00 刚好和调试结果一致，证明了E和M的存储满足以上规律。
二、指数E从内存中取出
上面介绍的是指数E是如何存入内存中的。下面介绍指数E如何从内存中取出。指数E从内存中取出还可以再分成三种情况：
1.E不全为0或不全为1
浮点数就采用下面的规则表示，实际上是指数E存储的逆运算，即指数E的计算值减去127（或1023），得到真实值，再将有效数字M前加上第一位的1。
示例：
已知二进制序列：0 01111110 00000000000000000000000
1，可知存储于内存中的E为：01111110 ==> 化为十进制：126
==> 真实的E为：126 - 127 = -1
2，存储于内存中的有效数字M为：00000000000000000000000 ==> 前面加上整数位1：1.0
3,符号位为：0
4，最终，得到的二进制表达为：(-1)^0 * 1.0 * 2^(-1) = 0.1 ==> 十进制：0.5
2.E全为0
这时，浮点数的指数E等于1-127（或者1-1023）即为真实值，有效数字M不再加上第一位的1，而是还原为0.xxxxxx的小数。这样做是为了表示±0，以及接近于0的很小的数字。
示例：
(-1)^S * 0.XXXXXX * 2^(-126) 或 (-1)^0 * 1.0 * 2^(-1022)
3.E全为1
这时，如果有效数字M全为0，表示±无穷大（正负取决于符号位s）
三、问题的解决
现在根据上面的知识来解决前言遗留下来的问题。
int main()
{
int n = 9;
//0000000000000000000000000001001--补码
//0 00000000 0000000000000000001001
//S E M
//0 -126 0.0000000000000000001001
//(-1)^0 * 0.0000000000000000001001 * 2^(-126) ---> 0
//E在内存中为全0
float* pFloat = (float*)&n;
printf("%d\n", n);//9
printf("%f\n", *pFloat);//0.000000
*pFloat = 9.0;
//1001.0
//1.001 * 2^3
//(-1)^0 * 1.001 * 2^3
//S=0 E=3 M=1.001
//0 10000010 00100000000000000000000--补码
//(-1)^0 * 1.001 * 2^3
printf("%d\n", n);//补码等于原码，打印出1,091,567,616
printf("%f\n", *pFloat);//9.000000
return 0;
}
解释：
第一个问题是整型在内存中存储，以浮点型在内存中取出的问题。
1，首先整型9在内存中存储，以整型在内存中取出，以 %d 形式打印，打印的还是9。
2，其次整型9在内存中存储，通过指针强制类型转换为浮点型指针，再以浮点型从内存中取出，并以 %f 形式打印。
整型9在内存中存储的补码可以写出来：0000000000000000000000000001001
按照浮点型存储： 0 00000000 0000000000000000001001
S E M
S,E,M的值分别为： 0 -126 0.0000000000000000001001
这个问题实际上是E全0的问题，真实值E是1 - 127，有效数字M无需补整数位，M = 0.0000000000000000001001
二进制表达为：(-1)^0 * 0.0000000000000000001001 * 2^(-126) ---> 0
所以这就是为什么打印的结果为0.000000。
第一个问题是浮点型在内存中存储，以整型在内存中取出的问题。
n的内容已经通过浮点型指针修改成了浮点型。
1，首先浮点型9.0在内存中存储，以浮点型在内存中取出，以 %f 形式打印，打印的还是9.000000。
2，其次浮点型9.0在内存中存储，以整型在内存中取出，以 %d 形式打印。
十进制9.0化为二进制为：1001.0
1001.0 = (-1)^0 * 1.001 * 2^3
在内存中存储的二进制序列：0 00000011 00100000000000000000000
S E M
以整型打印打印的则是二进制序列00000001100100000000000000000000的原码形式，通过计算得到其十进制为：1091567616
值得注意的是：
%f 只能打印浮点型的数据，不能打印整型的数据；%d 只能打印整型的数据，不能打印浮点型的数据。
00000001100100000000000000000000的计算可通过计算器算得，如下图：
754
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
