经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置:技术经验 » 程序设计 » C 语言 » 查看文章
C语言中魔性的float浮点数精度问题
来源:jb51  时间:2021/1/4 9:51:42  对本文有异议

从一个问题引入

如果你以前接触过C语言,那么对下面的这段代码一定很熟悉:

  1. #include <stdio.h>
  2.  
  3. int main(void)
  4. {
  5. float f_num1 = 21.75;
  6. float f_num2 = 13.45;
  7. printf("f_num1 = %f\n", f_num1);
  8. printf("f_num2 = %f\n", f_num2);
  9. printf("f_num1 + f_num2 = %f\n", f_num1 + f_num2);
  10.  
  11. return 0;
  12. }
  13.  

相信很多人不用运行,能够直接报出答案, f_num1 = 21.75 , f_num2 = 13.45 , f_num1 + f_num2 = 35.2 ,无论是从常识还是理论角度都不难理解。

下面我们运行一下程序,验证我们的猜测正不正确:

f_num1 = 21.750000
f_num2 = 13.450000
f_num1 + f_num2 = 35.200001

f_num1 和 f_num2 的结果和我们预想的一样,之所以后面多了四个0,是因为 %f 默认保留6位有效数字。但是 f_num1 + f_num2 的结果是什么鬼,这个 35.200001 是从哪里来的?

是不是一下子颠覆了我们的认知?

惊不惊喜,意不意外,刺不刺激?是不是发现自从学了C语言,连简单的算术都不会算了?

别急,还有更令你崩溃的。

如果是C++呢

下面我们看看以上程序的C++版本:

  1. #include<iostream>
  2. using namespace std;
  3.  
  4. int main(void)
  5. {
  6. float f_num1 = 21.75;
  7. float f_num2 = 13.45;
  8. cout << "f_num1 = " << f_num1 << endl;
  9. cout << "f_num2 = " << f_num2 << endl;
  10. cout << "f_num1 + f_num2 = " << f_num1 + f_num2 << endl;
  11. return 0;
  12. }
  13.  

直接来看输出结果吧:

f_num1 = 21.75
f_num2 = 13.45
f_num1 + f_num2 = 35.2

很神奇是不是?因为这个结果看起来正常多了。

看到这里,相信我们的心里都有老大一个疑问:为什么C程序和C++程序对同样的数字处理,输出的结果却不一样的? cout 到底做了些什么?

cout的神奇之处

为了验证cout对浮点数的处理,我们不妨看一下下面的程序:

  1. #include <iostream>
  2. using namespace std;
  3.  
  4. int main(void)
  5. {
  6. float num1 = 5;
  7. float num2 = 5.00;
  8. float num3 = 5.14;
  9. float num4 = 5.140000;
  10. float num5 = 5.123456;
  11. float num6 = 5.987654321;
  12. cout << "num1 = " << num1 << endl;
  13. cout << "num2 = " << num2 << endl;
  14. cout << "num3 = " << num3 << endl;
  15. cout << "num4 = " << num4 << endl;
  16. cout << "num5 = " << num5 << endl;
  17. cout << "num6 = " << num6 << endl;
  18.  
  19. return 0;
  20. }

看结果来分析比较直观,运行以上程序,结果如下:

num1 = 5
num2 = 5
num3 = 5.14
num4 = 5.14
num5 = 5.12346
num6 = 5.98765

从 num1 和 num2 , num3 和 num4 这两组结果可以知道, cout 对于 float 类型数值小数点后面的0是直接省去了的(这点和C语言格式化输出的%g有点像)。

从 num5 和 num6 两组结果不难分析出, cout 对于浮点型数值,最多保留6位有效数字。

以上是cout处理浮点数时的特点,应该记住。

事实上,我们使用 iostream 库里的 cout.setf 不难使 cout 恢复精度。我们对上面的代码修改如下:

  1. #include<iostream>
  2. using namespace std;
  3.  
  4. int main(void)
  5. {
  6. float f_num1 = 21.75;
  7. float f_num2 = 13.45;
  8. cout.setf(ios_base::fixed, ios_base::floatfield);
  9. cout << "f_num1 = " << f_num1 << endl;
  10. cout << "f_num2 = " << f_num2 << endl;
  11. cout << "f_num1 + f_num2 = " << f_num1 + f_num2 << endl;
  12. return 0;
  13. }
  14.  

输出的结果就与C语言版本一模一样了:

f_num1 = 21.750000
f_num2 = 13.450000
f_num1 + f_num2 = 35.200001

答案呼之欲出

文章写到这里,相信你已经看出来问题的所在了。

不错,之所以结果不一样,正是由于精度引起的!

让我们回顾一下官方教材里关于 float 精度的描述:

浮点型和表示单精度、双精度和扩展精度值。 C++ 标准指定了一个浮点数有效位数的最小值,然而大多数编译器都实现了更高的精度。 通常, float 以一个字(32比特)来表示, double 以2个字(64比特)来表示, long double 以3或4个字(96或128比特)来表示。一般来说,类型 float 和 double 分别有7和16个有效位;类型 long double 则常常被用于有特殊浮点需求的硬件,它的具体实现不同,精度也各不相同。( 《C++ Primer第五版》 )

由以上描述,我们不难知道,对于 float 来说,最多只有7个有效位,这也就意味着,当实际存储的精度大于 float 的精度范围时,就会出现精度丢失现象。

为了进一步佐证上述问题,我们不妨将 float 的数值放大10亿倍,看看里面存储的值到底是多少:

  1. #include<iostream>
  2. using namespace std;
  3.  
  4. int main(void)
  5. {
  6. float f_num1 = 21.75;
  7. float f_num2 = 13.45;
  8. cout.setf(ios_base::fixed, ios_base::floatfield);
  9. int billion = 1E9;
  10. float f_num10 = f_num1 * billion;
  11. float f_num20 = f_num2 * billion;
  12. cout << "f_num1 = " << f_num1 << endl;
  13. cout << "f_num2 = " << f_num2 << endl;
  14.  
  15. cout << "f_num10 = " << f_num10 << endl;
  16. cout << "f_num20 = " << f_num20 << endl;
  17. return 0;
  18. }
  19.  

以上程序运行结果如下:

f_num1 = 21.750000
f_num2 = 13.450000
f_num10 = 21749999616.000000
f_num20 = 13449999360.000000

由此我们不难推断,21.75在实际存储时,并不是存储的21.75,而是21.749999616,同样的,12.45存储的是12.449999360,这样计算出来之后自然就会造成结果的不正确。

再看一个例子

我们再来看一个精度丢失造成运算结果不正确的例子。

  1. #include<iostream>
  2. using namespace std;
  3.  
  4. int main(void)
  5. {
  6. float num1 = 2.3410E23;
  7. float num2 = num1 + 1.0f;
  8. cout << "num2 - num1 = " << num2 - num1 << endl;
  9. return 0;
  10. }
  11.  

如果精度不丢失,运算结果应该为1才对,可是因为精度丢失,导致最后的加1实际和没加效果一样,计算出来的结果是0。

num2 - num1 = 0

怎么解决

那么,既然float有这么多稀奇古怪的问题,应该怎么去解决和避免呢?

首先,当然推荐大家在编程时尽量使用高精度的浮点类型

比如double就比float精度要高,很多时候,使用double能够避免很多问题,比如本文一开始提到的问题,如果使用double就能完美解决:

  1. #include <stdio.h>
  2.  
  3. int main(void)
  4. {
  5. double f_num1 = 21.75;
  6. double f_num2 = 13.45;
  7. printf("f_num1 = %lf\n", f_num1);
  8. printf("f_num2 = %lf\n", f_num2);
  9. printf("f_num1 + f_num2 = %lf\n", f_num1 + f_num2);
  10.  
  11. return 0;
  12. }
  13.  

大家可以自己运行一下看看结果。

double 类型可以解决大部分精度丢失问题,基本上满足日常使用了,但是仍然不能避免精度丢失( double 也有精度限制),这时候就需要想另外的方法来解决了。

万能的cout

前面提到过, cout 其实是可以解决这种精度丢失问题的,所以如果不是对效率要求过高或者要求格式化输出(其实 cout 也可以实现格式化输出,此处不详细展开)必须使用 printf ,在编写C++程序时,建议使用 cout 代替 printf 。

写在最后

本文只是简单的介绍了一下浮点型数值的精度问题,如果要深入细究,肯定不止这么多内容,比如浮点型数值在内存中是如何存储的?在字节里是如何分布 的?这才是真正核心的原理部分。在这里只浅尝辄止地讲述了一下,但相信阅读者已经对精度问题有了一个初步的认识。

到此这篇关于C语言中魔性的float浮点数精度问题的文章就介绍到这了,更多相关C语言float浮点数精度 内容请搜索w3xue以前的文章或继续浏览下面的相关文章希望大家以后多多支持w3xue!

 友情链接:直通硅谷  点职佳  北美留学生论坛

本站QQ群:前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

W3xue 的所有内容仅供测试,对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接(目前9元/月)请联系QQ:27243702 沸活量
皖ICP备17017327号-2 皖公网安备34020702000426号