我们知道，整型在内存中的存储比较简单，在内存中都是以二进制来存储的。然而，浮点型在内存中的存储较为复杂。下面来详细探讨：
直接举一个例子：

int main()
{
int n = 9;
float *pFloat = (float *)&n;
printf("n的值为：%d\n",n);
printf("*pFloat的值为：%f\n",*pFloat);
*pFloat = 9.0;
printf("num的值为：%d\n",n);
printf("*pFloat的值为：%f\n",*pFloat);
return 0;
}

或许可以看出第一个和第四个printf打印出来分别是9和9.000000 ，浮点型精度保留小数点后6位。

但是第二个和第三个printf打印出来的结果就比较奇怪了：

为什么会是这样的结果呢？

请看下面：

浮点数的存储规则：

根据国际标准IEEE（电气和电子工程协会） 754，任意一个二进制浮点数V可以表示成下面的形式：

• (-1)^S * M * 2^E

• (-1)^S表示符号位，当S=0，V为正数；当S=1，V为负数。

• M表示有效数字，大于等于1，小于2。

• 2^E表示指数位。

到底是什么意思呢？

举个例子：

对于十进制数5.0 ，转换成二进制是： 101 .0，即 1.01*2^2，
即 (-1)^0 * 1.01 * 2^2
因为这是二进制，二进制用科学计数法就是2的多少次方，用十进制就是10的多少次方。

按照上面的规定：所以S是0 ， M是1.01，E是2。

对于十进制 -5.0 ，写出二进制是 -101.0 ，
相当于 (-1)^1 * 1.01 * 2^2 , 所以S 是1，M是1.01，E是2.

标准规定：

对于32位的浮点数，最高的1位是符号位s，接着的8位是指数E，剩下的23位为有效数字M。

在这32个比特位中，最高1位是S使用，接着的8位是E使用，剩下的23位是M使用。

对于64位的浮点数，最高的1位是符号位S，接着的11位是指数E，剩下的52位为有效数字M。

在这64个比特位中，最高1位是S使用，接着的11位是E使用，剩下的52位是M使用。

这是为什么？没有为什么，这是规定。

对于有效数字M，还有更为特别的规定：

对于十进制数字，假如一个数230，写成科学计数法，是
2.30 * 10^2，有效位是2.30，这个有效位的范围在1~10之间。
而对于二进制数字，有效位M的范围就在1~2之间。
所以M可以写成 1.xxxxxxxxxxxx的形式，
在保存M时，默认只保存 1.xxxxxxxxxxx 中的xxxxxxxxxxx这一部分，这个1不保留。比如1.055，只保留055进计算机，这个1不保留。

总结：对于有效位M，只保留小数点后面的位数，不保留小数点前面的1

下面看指数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。

然后，指数E从内存中取出还可以再分成三种情况：
E不全为0或不全为1情况：

这时，浮点数就采用下面的规则表示，即指数E的计算值减去127（或1023），得到真实值，再将
有效数字M前加上第一位的1。
比如：
0.5（1/2）的二进制形式为0.1，因为对于二进制来说，小数点后面的指数就是2^-1, 2^-2 , 2^-3 ,等等。
由于规定正数部分必须为1，即将小数点右移1位，则为
1.0*2^(-1)，则E为-1+127=126，表示为
01111110，而尾数1.0去掉整数部分为0，补齐0到23位00000000000000000000000，则其二进
制表示形式为:
0 01111110 00000000000000000000000

E全为0情况：
这时，浮点数的指数E等于1-127（或者1-1023）即为真实值，

**有效数字M不再加上第一位的1，而是还原为0.xxxxxx的小数。**这样做是为了表示±0，以及接近于
0的很小的数字。
0 01111110 00000000000000000000000

E全为1情况

这时，如果有效数字M全为0，表示±无穷大（正负取决于符号位s）；

对于S ，怎么存进去的，就怎么取出来。

话不多说，直接看刚才例题的例子：
对于整型 9 ，强转成浮点型存入内存中是怎样存的呢？

首先，将 9强转后成浮点型的 9 写成科学计数法：
1001 --> (-1)^0 * 1.001 * 2^3
S=0,E = 3,M = 1.001
存入内存中如下图：

s原封不动存进最高位 0 ，

对于这个32位的浮点数，E需要先+127后，再存进去，E+127 = 130，130的二进制序列为10000010，就存入最高位接下来的后八位。

M是1.001，丢掉小数点前面的1，就把001存入内存中，M占了23个比特位，存001只存了3个比特位，剩下的二十个比特位，就全补0 ， 即 00100000000000000000000
所以浮点数9存入内存中为：

0 10000010 00100000000000000000000

解读它：计算机中是以十六进制来展示的，那么我们就先转换成十六进制

0100 0001 0001 0000 0000 0000 0000 0000

转成十六进制是：0x41 10 00 00

由于计算机是小端存储，故读取时是
41 10 00 00

符合预期。

在这道例题中

int main()
{
int n = 9;
float *pFloat = (float *)&n;
printf("n的值为：%d\n",n);
printf("*pFloat的值为：%f\n",*pFloat);
*pFloat = 9.0;
printf("num的值为：%d\n",n);
printf("*pFloat的值为：%f\n",*pFloat);
return 0;
}

9的原码是

00000000000000000000000000001001

正数的补码与原码相同，故9的补码也是

00000000000000000000000000001001

把这个二进制序列交给*pFloat , 它会认为这是一个浮点数的二进制序列，
把最高位当成符号位，接下来的八位当成指数E，后面的23位当成有效数字M,

0 00000000 00000000000000000001001

故S =0，E = 0 - 127 = -127，
由于E为全0 的数，在全0 中，M读取出来时候不再补1，而是补0，
故M = 0.00000000000000000001001
即 (-1)^0 * 0.00000000000000000001001 * 2^(-127) 相当于1成一个非常非常无限接近于0的数，所以结果无限接近于0
打印出来%f打印到小数点第六位，故打印结果为0.000000

*pFloat = 9.0;
printf("num的值为：%d\n",n);

前面说过 ，
浮点数9存入内存中为：

0 10000010 00100000000000000000000

对于这个代码，*pFloat 是一个浮点数，以%d形式打印出来，%d会认为9是的二进制序列是整型存储方式。

01000001000100000000000000000000

直接翻译成整型十进制数，结果为：

刚好符合预期。