C语言的本质（4）——浮点数的本质与运算

C语言的本质（4）——浮点数的本质与运算

C语言规定了3种浮点数，float型、double型和long double型，其中float型占4个字节，double型占8个字节，longdouble型长度要大于等于double型，本文档将以float型为例进行介绍，double型和long double型只是比float型位数长，原理都是一样的。

float型可以表示的范围是-3.402823466e38~3.402823466e38，而作为同为4个字节的定点数却只能表示-2147483648~2147483647的范围，使用同样的内存空间，浮点数却能比定点数表示大得多的范围，这是不是太神奇了？既然浮点数能表示这么大的范围，那么我们为何不使用浮点数来代替定点数呢？

先不说浮点数实现起来比较复杂，有些处理器还专门配置了硬件浮点运算单元用于浮点运算，主要原因是浮点数根本就无法取代定点数，因为精度问题。鱼和熊掌不可兼得，浮点数表示了非常大的范围，但它失去了非常准的精度。在说明精度问题前，我们先了解一下浮点数的格式。

ANSI/IEEEStd 754-1985标准

IEEE 754是最广泛使用的二进制浮点数算术标准，被许多CPU与浮点运算器所采用。IEEE754规定了多种表示浮点数值的方式，在本文档里只介绍32bits的float浮点类型。它被分为3个部分，分别是符号位S（sign bit）、指数偏差E（exponent bias）和小数部分F（fraction）。

aaarticlea/png;base64,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" alt="" />

其中S位占1bit，为bit31。S位为0代表浮点数是正数，S位为1代表浮点数是负数，比如说0x449A522C的S位为0，表示这是一个正数，0x849A522C的S位为1，表示这是一个负数。

E位占8bits，为bit23~bit30。E位代表2的N次方，但需要减去127，比如说E位为87，那么E位的值为2（87-127）=9.094947017729282379150390625e-13。

F位占23bits，为bit0~bit22。F位是小数点后面的位数，其中bit22是2-1=0.5，bit21是2-2=0.25，以此类推，bit0为2-23=0.00000011920928955078125。但F位里隐藏了一个1，也就是说F位所表示的值是1+（F位bit22~bit0所表示的数值），比如说F位是0b10100000000000000000001，只有bit22、bit20和bit0为1，那么F位的值为1+(2-1+2-3+2-23)，为1.62500011920928955078125。

综上所述，从二进制数换算到浮点数的公式为：(-1)S×2E-127×(1+F)。但还有几个特殊的情形：

1、若E位为0并且F位也为0时表示浮点数0，此时浮点数受S位影响，表现出+0和-0两种0，但数值是相等的。比如二进制数0x00000000表示+0，二进制数0x80000000表示-0。

2、若E位为0并且F位不为0时浮点数为(-1)S×2-126×F，注意，E位的指数是-126，而不是0-127=-127，而且F位是0.xx格式而不是1.xx格式，比如0x00000001的浮点数为2-126×2-23=1.4012984643248170709237295832899e-45，而不是20-121×（1+2-23）。一旦E为不为0，从0变为1，不是增加2倍的关系，因为公式改变了。

3、若E位为255并且F位不为0时表示非数值，也就是说是非法数，例如0x7F800001。

4、 若E位为255并且F位为0时表示无穷大的数，此时浮点数受S位影响，例如0x7F800000表示正无穷大，0xFF800000表示负无穷大。当我们使用1个数除以0时，结果将被记作0x7F800000。

浮点型在多个处理器间通信时，传递的数值是它的二进制数，比如说1234.5678这个浮点数的二进制数是0x449A522B，如果使用串口发送的话，就会发现串口里发送的是0x44、0x9A、0x52和0x2B这4个数（发送的顺序也可能是逆序，这与约定的字节序有关，与浮点格式无关），接收端接收到这4个数字后再组合成0x449A522B，按照IEEE 754的定义被解析成1234.5678，这样就实现浮点数通信了。如果两个处理器所使用的浮点数规则不同，则无法传递浮点数。

浮点数的换算

下面来看看浮点数与二进制数如何转换。

1、二进制数换算成浮点数：

假如在内存中有一个二进制数为0x449A522C，先将十六进制转换成二进制，如下：

0100 0100  1001  1010 0101  0010  0010 1100

按照SEF的格式分段，如下：

0 10001001  00110100101001000101100

这个数值不是特殊的情形，可以按照公式(-1)S×2E-127×(1+F)转换。S位的值为(-1)0=1，E位的值为2137-127=1024。F位的值为1+2-3+2-4+2-6+2-9+2-11+2-14+2-18+2-20+2-21= 1.205632686614990234375。最终结果为1×1024×1.205632686614990234375=1234.56787109375。

其中F位比较长，使用二进制方式转换比较麻烦，也可以先转换成十六进制再计算，转换为十六进制如下：

0011 0100  1010  0100 0101  1000

0x3  0x4   0xA   0x4  0x5   0x8

F位为23bits，需要在最后补一个0凑成24bits，共6个十六进制数。F位的值为1+3×16-1+4×16-2+10×16-3+4×16-4+5×16-5+8×16-6=1.205632686614990234375，与上面使用二进制方法得到的结果相同。

2、浮点数换算成二进制数：

下面我们将-987.654e30换算成二进制数。我们先不看符号位，将987.654e30归一化为整数部分为1的形式，也就是写作987.654e30=2E-127×（1+F）的标准形式，其中E=log(987.654e30)/log2+127=109.6+127，取E位的整数值为109+127=236，再求F=987.654e30/2236-127-1=0.52172193，这个小数位数保留8位就够了，已经超出了7位的精度。然后我们求小数部分的二进制数，这个转换就没啥好说的了，依次减去2的幂，从2-1一直到2-23，够减的位置1，不够减的位置0，例如，2-1为0.5，0.52172193-0.5=0.02172193，F位的bit22置1，2-2为0.25，0.02172193不够减，F位的bit21置0，2-3为0.125，0.02172193不够减，F位的bit20置0，2-4为0.0625，0.02172193不够减，F位的bit19置0……，一直算到F位的bit0，这样就得到F位的数值。

如果觉得使用二进制方式转换太麻烦的话也可以使用十六进制进行转换。16-1为0.0625，0.52172193/0.0625=8.3，说明够减8个，记做0x8，0.52172193-0.0625×8=0.02172193，16-2为0.00390625，0.02172193/0.00390625=5.6，说明够减5个，加上刚才的0x8记做0x85，以此类推：

	16的-N次幂	被减数	十六进制数	减后的数
1	0.0625	0.52172193	0x8	0.02172193
2	0.00390625	0.02172193	0x85	0.00219068
3	0.000244140625	0.00219068	0x858	0.000237555
4	0.0000152587890625	0.000237555	0x858F	0.0000086731640625
5	0.00000095367431640625	0.0000086731640625	0x858F9	0.00000009009521484375
6	0.000000059604644775390625	0.00000009009521484375	0x858F91

一直凑够23bits，也就是6个十六进制，得到0x858F91，换算成二进制如下所示：

1000 0101  1000  1111 1001  0001

由于只有23bits有效，因此需要去掉最后一个bit，二进制本着0舍1入的原则，变成

1000 0101  1000  1111 1001  001

最后需要再补上前面的S位和E位。由于是负数，S位为1。E位为236，二进制形式为1110 1100，将S、E、F位组合在一起就形成了：

1 1110 1100  1000  0101 1000  1111  1001 001

从左边最高位开始，4个一组合并成十六进制：

1111 0110  0100  0010 1100  0111  1100 1001

换算成十六进制为：

0xF  0x6   0x4   0x2  0xC   0x7  0xC  0x9

所以-987.654e30换算成二进制数为0xF642C7C9。

浮点数的精度

在前面的讲解中可以看到1.xx这个数量级的最小数是2-23，对应的十进制数值为1.00000011920928955078125，可以精确表示到小数点后23位，但有些C语言书上却说float型的有效位只有6~7位，这是为什么？

这是因为二进制小数与十进制小数没有完全一一对应的关系，二进制小数对于十进制小数来说相当于是离散的而不是连续的，我们来看看下面这些数字：

二进制小数        十进制小数

2-23       1.00000011920928955078125

2-22       1.0000002384185791015625

2-21       1.000000476837158203125

2-20       1.00000095367431640625

2-19       1.0000019073486328125

2-18       1.000003814697265625

不看S位和E位，只看F位，上表列出了1.xx这个数量级的6个最小幂的二进制小数，对应的十进制在上表的右边，可以看到使用二进制所能表示的最小小数是1.00000011920928955078125，接下来是1.0000002384185791015625，这两个数之间是有间隔的，如果想用二进制小数来表示8位有效数（只算小数部分，小数点前面的1是隐藏的默认值）1.00000002、1.00000003、1.00000004...这些数是无法办到的，而7位有效数1.0000001可以用2-23来表示，1.0000002可以用2-22来表示，1.0000003可以用2-23+2-22来表示。从这个角度来看，float型所能精确表示的位数只有7位，7位之后的数虽然也是精确表示的，但却无法表示任意一个想表示的数值。

但还是有一些例外的，比如说7位有效数1.0000006这个数就无法使用F位表示，二进制小数对于十进制小数来说相当于是离散的，刚好凑不出1.0000006这个数，从这点来看float型所能精确表示的位数只有6位。至于5位有效值的任何数都是可以使用F位相加组合出来的，即便是乘以E位的指数后也是可以准确表示出来的。

因此float型的有效位数是6~7位，但这个说法应该不是非常准确，准确来说应该是6位，C语言的头文件中规定也是6位。

对于一个很大的数，比如说1234567890，它是F位乘上E位的系数被放大了的，但它的有效位仍然是F位所能表示的6位有效数字。1234567890对应的二进制数是0x4E932C06，其中F位的数值为1.1497809886932373046875，E位的数值为230=1073741824，1073741824×1.1497809886932373046875=1234567936，对比1234567890，也只有高7位是有效位，后3位是无效的。int型定点数可以准确的表示1234567890，而float浮点数则只能近似的表示1234567890，精度问题决定了float型根本无法取代int型。

浮点数的比较

float型的有效位数是6位，那么我们在用float型运算时就要注意了，来看下面这段程序：

#include <stdio.h>

int main(void)
{
   float a = 9.87654321;
   float b = 9.87654322;

   if(a > b)
    {
       printf("a > b\n");
    }
   else if(a == b)
    {
       printf("a == b\n");
    }
   else
    {
       printf("a < b\n");
       }

   return 0;
}

按照我们平时的经验来说这段程序应该走a < b的分支，但程序运行的结果却走了a == b的分支，原因就是float型的精度问题，float型无法区分出小数点后的第8位数，在内存中，a和b的二进制数都是0x411E0652，因此就走了a == b的分支。

某些编译器在编译时会发现a和b的值超出了浮点数的精度，会产生一个告警，提示数据超过精度，但有些编译器则不会做任何提示。最可怕的是有一类编译器，调试窗口里显示的长度超出float型的精度，比如说a的值显示为9.87654321，b的值显示为9.87654322，但在运行时，硬件可不管这套，硬件认为这2个数都是0x411E0652，因此实际运行结果是a == b的分支。

由于精度这个问题的限制，我们在浮点数比较时就需要加一个可接受的精度条件来做判决，比如说上面的这个问题，如果我们认为精度在0.00001就足够了，那么a - b之差的绝对值只要小于0.00001，我们就认为a和b的值是相等的，大于0.00001则认为不等，还要考虑到a - b正负等情况，因此可以将上面的程序改写为：

#include <stdio.h>

int main(void)
{
   float a = 9.87654321;
   float b = 9.87654322;

   if(a - b < -0.00001)
    {
       printf("a < b\n");
    }
   else if(a - b > 0.00001)
    {
       printf("a > b\n");
    }
   else
    {
       printf("a == b\n");
       }

   return 0;
}

例子中a和b之差的绝对值小于0.00001，因此认为a和b是相等的，运行程序，也正确的打印了a == b。

为什么我们要做一个精度的限定？这是因为我们在应用中的精度往往要低于硬件的6位精度。

浮点数的加减

二进制小数与十进制小数之间不存在一一对应的关系，因此某些十进制很整的加减法小数运算由二进制小数来实现就表现出了不整的情况，来看下面的例子：

#include <stdio.h>

int main(void)
{
   float a = 10.2;
   float b = 9;
   float c;

    c= a - b;

       printf("%f\n", c);

   return 0;
}

如果用十进制计算的话变量c应该为1.2，在Visual C++ 2010环境下实验输出为1.200000，但实际上c变量的值是1.1999998，只不过是在输出时被四舍五入为1.200000罢了。在内存中c变量的二进制数是0x3F999998，它对应的浮点数是0.19999980926513671875。如果我们将printf函数%f的格式改为%.7f格式，就会看到c变量输出的值是1.1999998。

两个数量级相差很大的数做加减运算时，数值小的浮点数会受精度限制而被忽略，看下面的例子：

#include <stdio.h>

int main(void)
{
   float a = 987654321;
   float b = 987.654322;
   float c;

    c= a + b;

   printf("%f\n", c);

   return 0;
}

Visual C++ 2013上的计算结果为987655296.000000，而实际的真实值为987655308.654322，二进制值为0x4E6B79B2对应987655296，就是987655296.000000。可以看出有效值是6位，如果按四舍五入的话可以精确到8位，其中变量b贡献的有效数值只有2位。

987654321

+    987.654322

--------------------------------

987655308.654322    真实值

987655296.000000    计算值

987655296           二进制值，0x4E6B79B2

对于这种数量级相差很大的计算，计算结果会保证高位数有效，数量级小的数相对计算结果显的太小了，不能按自身6位的精度保持，而是需要按照计算结果的6位精度保持。

C语言中有关浮点数的定义

C语言对浮点数做了一些规定，下面是摘自VisualC++ 2013头文件float.h中有关float型的定义，如下：

#define FLT_DIG         6                       /* # of decimal digitsof precision */
#define FLT_EPSILON     1.192092896e-07F        /* smallest such that 1.0+FLT_EPSILON!= 1.0 */
#define FLT_GUARD       0
#define FLT_MANT_DIG    24                      /* # of bits in mantissa*/
#define FLT_MAX         3.402823466e+38F        /* max value */
#define FLT_MAX_10_EXP  38                      /* max decimal exponent*/
#define FLT_MAX_EXP     128                     /* max binary exponent */
#define FLT_MIN         1.175494351e-38F        /* min positive value */
#define FLT_MIN_10_EXP  (-37)                   /* min decimal exponent */
#define FLT_MIN_EXP     (-125)                  /* min binary exponent */

其中FLT_DIG定义了float型的十进制精度，是6位，与我们上面的讨论是一致的。

FLT_EPSILON定义了float型在1.xx数量级下的最小精度，1.xx数量级下判断浮点数是否为0可以使用这个精度。

FLT_MANT_DIG定义了float型F位的长度。

FLT_MAX定义了float型可表示的最大数值。

FLT_MAX_10_EXP定义了float型十进制的最大幂。

FLT_MAX_EXP定义了float型二进制的最大幂。

FLT_MIN定义了float型所能表示的最小正数。

FLT_MIN_10_EXP定义了float型十进制的最小幂。

FLT_MIN_EXP定义了float型二进制的最小幂。

float.h文件里对其它的浮点数也做了规定，有兴趣的读者可以打开float.h头文件继续研究。