浮点数的内存存储！！！

来源: http://www.cnblogs.com/jillzhang/archive/2007/06/24/793901.html

      本人对其中的一些细节和错误进行了精心的调整

C语言中，对于浮点型的数据采用单精度类型(float)和双精度类型(double)来存储：

float 数据占用 32bit；

double 数据占用 64bit；

我们在声明一个变量 float f = 2.25f 的时候，是如何分配内存的呢？

其实不论是 float 类型还是 double 类型，在存储方式上都是遵从IEEE的规范：

float 遵从的是 IEEE R32.24；

double 遵从的是 IEEE R64.53；

 

单精度或双精度在存储中，都分为三个部分：

符号位  (Sign) ： 0 代表正数， 1 代表为负数；  

指数位 (Exponent)：用于存储科学计数法中的指数数据；

尾数部分 (Mantissa)：采用移位存储尾数部分；

 

单精度 float 的存储方式如下：

 

双精度 double 的存储方式如下：

 

R32.24 和 R64.53 的存储方式都是用科学计数法来存储数据的，比如：

8.5  用十进制表示为：8.5 * 10⁰

120.5 用十进制表示为：1.205 * 10²

 

而计算机根本不认识十进制的数据，他只认识0和1。所以在计算机存储中，首先要将上面的数更改为二进制的科学计数法表示：

8.5   用二进制表示为：1000.1

118.5 用二进制表示为：1110110.1

  

而用二进制的科学计数法表示 1000.1，可以表示为1.0001 * 2³

而用二进制的科学计数法表示 1110110.1，可以表示为1.1101101 * 2⁶

任何一个数的科学计数法表示都为1. xxx * 2ⁿ ，尾数部分就可以表示为xxxx，由于第一位都是1嘛，干嘛还要表示呀？所以将小数点前面的1省略。

由此，23bit的尾数部分，可以表示的精度却变成了24bit，道理就是在这里。

 

那 24bit 能精确到小数点后几位呢？我们知道9的二进制表示为1001，所以 4bit 能精确十进制中的1位小数点，24bit就能使 float 精确到小数点后6位；

 

而对于指数部分，因为指数可正可负(占1位)，所以8位的指数位能表示的指数范围就只能有7位（相当于有符号的char），范围是:-127至128。所以指数部分的存储采用移位存储，存储的数据为元数据 +127。

注意：

元数据+127：大概是指“指数”从0111 1111开始（表示+127）至1000 0000（表示-128）

            元数据：+127 （也就是指数为0的情况）（只是因为8位指数位是-128 - 127，为了防止出现负数，所以都加上127，故元数据就是+127）

                     所以，10000000表示指数1 (127 + 1 = -128 --> 10000000 ) ；

 指数为 3，则为 127 + 3 = 130（存储的话，也就相当于-126），表示为 01111111 + 11 = 1000 0010 ；

下面就看看 8.5 和 118.5 在内存中真正的存储方式:

8.5 用二进制表示为：1000.1

8.5 用二进制的科学计数法表示为: 1.0001* 2³ ，按照上面的存储方式：

    符号位为：0，表示为正；

    指数位为：3+127=130，即 1000 0010；

    尾数部分为：0001；

故8.25的存储方式如下图所示：

 

而单精度浮点数118.5的存储方式如下图所示：

118.5 用二进制表示为：1110110.1

118.5 用二进制的科学计数法表示为: 1.1101101 * 2⁶ ，按照上面的存储方式：

    符号位为：0，表示为正；

    指数位为：6+127=133，即 1000 0101；

    尾数部分为：1101101；

 

那么如果给出内存中一段数据，并且告诉你是单精度存储的话，你将如何知道该数据的十进制数值呢？

其实就是对上面运算的反推过程，比如给出如下内存数据：01000010111011010000000000000000，

首先我们现将该数据分段：0  10000101  11011010000000000000000，在内存中的存储就为下图所示：

根据我们的计算方式，可以计算出这样一组数据表示为：

1101101*10^(133-127=6) = 1.1101101 * 2⁶ = 1110110.1=118.5

 

而双精度浮点数的存储和单精度的存储大同小异，不同的是指数部分和尾数部分的位数。所以这里不再详细的介绍双精度的存储方式了，只将118.5的最后存储方式图给出：

(嗯嗯，这个东西还是不太懂，好难啊，双精度的存储)

 

下面就这个知识点来解决一个疑惑，请看下面一段程序，注意观察输出结果：

程序1：：

#include <stdio.h>

int main()
{
	float a = 2.2, b = 2.25;
	printf("%f\n",a);
	printf("%f\n",b);

	return 0;
}

输出结果：

2.200000

2.250000

程序2：

	printf("%lf\n",a);
	printf("%lf\n",b);

输出结果：

2.200000

2.250000

程序3：

printf("%f\n",(double)a);
printf("%f\n",(double)b);

输出结果：

2.200000

2.250000

程序4：

	printf("%lf\n",(double)a);
	printf("%lf\n",(double)b);

输出结果：

2.200000

2.250000

程序5：

	printf("%.13lf\n",(double)a);
	printf("%.13lf\n",(double)b);

运行结果：

2.2000000476837

2.2500000000000

输出的结果可能让大家疑惑不解：

单精度的 2.2 转换为双精度后，精确到小数点后13位之后变为了2.2000000476837

而单精度的 2.25 转换为双精度后，变为了2.2500000000000

 在看下面这一点之前，我们先来看看这个：

对于printf函数而言：有一个“默认参数提升”（在printf这样的函数的可变参数列表中，不论作用域有没有原型，都适用这一规则）float型会被提升为double型，因此在printf函数中只会看到双精度。也就是说：不管我们以什么形式存储（float，double），存储到内存中都是以double型存储的（有人可能会很疑惑？？？为什么在内存中是以double形式存储的，不是%f是以float形式存储，而%lf是以double形式存储的吗？？，假如啊，我们说假如：：如果%f是以float存储的话，那么当我们多输出几位小数（超过7的那几位）的话，就应该不会出现后面乱七八糟的东西了，不是吗？？从上面的运行结果来看，就应该是以一种double形式存储的），不管我们以什么形式打印%f,%lf，打印的都会是默认的float型，也就是6位小数，除非我们强行输出12位小数，这些都可以从上面的运行结果看出。

然而对于scanf而言：float类型必须使用%f，double必须使用%lf

对于scanf，情况就完全不同了，它接受指针，这里没有类似的类型提升，（通过指针）向float存储和向double存储大不一样，因此，scanf区别%f和%lf

所以，要想保留小数位数，请使用（保留小数）

printf("%.8f",a);

为何 2.2 在转换后的数值更改了，而 2.25 却没有更改呢？

其实通过上面关于两种存储结果的介绍，我们大概就能找到答案。

2.25 的单精度存储方式表示为：0 10000000 00100000000000000000000

2.25 的双精度存储方式表示为：0 10000000 0000010000000000000000000000000000000000000000000000000

这样 2.25 在进行强制转换的时候，数值是不会变的。

而我们再看看 2.2，用科学计数法表示应该为：

将十进制的小数转换为二进制的小数的方法是：将小数*2，取整数部分。

   0.2×2=0.4，所以二进制小数第一位为0.4的整数部分0；

   0.4×2=0.8，第二位为0.8的整数部分0；

   0.8×2=1.6，第三位为1；

   0.6×2=1.2，第四位为1；

   0.2×2=0.4，第五位为0；

   ...... 这样永远也不可能乘到=1.0，得到的二进制是一个无限循环的排列 00110011001100110011...

 

对于单精度数据来说，尾数只能表示 24bit 的精度，所以2.2的 float 存储为:

但是这种存储方式，换算成十进制的值，却不会是2.2。

 

因为在十进制转换为二进制的时候可能会不准确（如：2.2），这样就导致了误差问题！

并且 double 类型的数据也存在同样的问题！

所以在浮点数表示中，都可能会不可避免的产生些许误差！

在单精度转换为双精度的时候，也会存在同样的误差问题。

而对于有些数据（如2.25），在将十进制转换为二进制表示的时候恰好能够计算完毕，所以这个误差就不会存在，也就出现了上面比较奇怪的输出结果。

对于浮点数存储转换为整形：

#include <stdio.h>

int main()
{
	float a = 12.5;
	printf("%d\n",a);
	printf("%d\n",(int)a);
	printf("%d\n",*(int *)&a);

	return 0;
}

window（vc+dev-c++）：

0

12

1095237632

linux：

-1796700504

12

1095237632

原因：浮点数是4个字节，12.5f转成二进制是：0 10000010 10010000000000000000000

      十六进制是：0x41480000，十进制就是：1095237632

      所以第二个和第三个结果也就很合理的解释了

      至于第一个：为什么会输出0（window下），我们需要知道的是：printf函数会将其转化为double类型存储，但是但是但是，最重要的一点就是：在x86芯片下：使用的是反字节序，高位字节和地位字节要反过来，所以：

float：0x41480000（在内存中：00004841）

double：0x40290000 00000000（在内存中：00 00 00 00 00 00 29 40）

又因为是以int输出：所以占用4个字节，前四个字节是0，所以输出的自然是0了，

嗯嗯，linux下就不太清楚了，望大家多来探讨！！！