浮点数在计算机中的存储方式,C/C++中为什么存储的浮点数会有偏差?


        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 的存储方式如下:

float1.png

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

float2.png


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

8.25  用十进制表示为:8.25 * 10^0

120.5 用十进制表示为:1.205 * 10^2


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

8.25   用二进制表示为:1000.01

118.5 用二进制表示为:1110110.1

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

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


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

        由此,23bit的尾数部分,可以表示的精度却变成了24bit,道理就是在这里。(float有效位数相应的也会发生变化,而double则不会,因达不到)那 24bit 能精确到小数点后几位呢?

        我们知道9的二进制表示为1001,所以 4bit 能精确十进制中的1位小数点,24bit就能使 float 精确到小数点后6位;而对于指数部分,因为指数可正可负(占1位),所以8位的指数位能表示的指数范围就只能用7位,范围是:-127至128。所以指数部分的存储采用移位存储,存储的数据为元数据 +127。


        注意:

        元数据+127:大概是指“指数”从00000000开始(表示-127)至11111111(表示+128)。所以,10000000表示指数1 (127 + 1 = 128 --> 10000000 ),指数为 3,则为 127 + 3 = 130,表示为 01111111 + 11 = 10000010 。


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

8.25 用二进制表示为:1000.01

8.25 用二进制的科学计数法表示为: 1.0001* 2^3 ,按照上面的存储方式:

        符号位为:0,表示为正;

        指数位为:3+127=130,即 10000011;

        数部分为:0001;


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

float3.png

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

float4.png

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

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

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

float5.png

        

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

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

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

float6.png

        

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

#
#
class 浮点数
    {
        static void Main(string[] args)
        {
            float f = 2.2f;
            double d = (double)f;
            Console.WriteLine(d.ToString("0.0000000000000"));
            //结果:"2.2000000476837"

            f = 2.25f;
            d = (double)f;
            Console.WriteLine(d.ToString("0.0000000000000"));
            //结果:"2.2500000000000"

            //2.25 - 2.2 = 0.05 ( 但实际结果不是0.05 )
            float f2 = 2.25f - 2.2f;
            Console.WriteLine(f2.ToString("0.0000000000000"));
            //结果:"0.0499999500000"
        }
    }
#
#

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

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

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


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

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

2.25 的单精度存储方式表示为:0 10000001 00100000000000000000000

2.25 的双精度存储方式表示为:0 10000000 0010010000000000000000000000000000000000000000000000000

        

        这样 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 存储为:

float7.png

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

        因为在十进制转换为二进制的时候可能会不准确(如:2.2),这样就导致了误差问题!并且 double 类型的数据也存在同样的问题!

        所以在浮点数表示中,都可能会不可避免的产生些许误差!在单精度转换为双精度的时候,也会存在同样的误差问题。

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


下一篇