乐趣区

关于c++:魔性的float浮点数精度问题

从一个问题引入

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

#include <stdio.h>

int main(void)
{
        float f_num1 = 21.75;
        float f_num2 = 13.45;
        printf("f_num1 = %f\n", f_num1);
        printf("f_num2 = %f\n", f_num2);
        printf("f_num1 + f_num2 = %f\n", f_num1 + f_num2);

        return 0;
}

置信很多人不必运行,可能间接报出答案, 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_num1f_num2 的后果和咱们料想的一样,之所以前面多了四个 0,是因为 %f 默认保留 6 位有效数字。然而 f_num1 + f_num2 的后果是什么鬼,这个 35.200001 是从哪里来的?
是不是一下子颠覆了咱们的认知?
惊不惊喜,意不意外,刺不刺激?是不是发现自从学了 C 语言,连简略的算术都不会算了?
别急,还有更令你解体的。

如果是 C ++ 呢

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

#include<iostream>
using namespace std;

int main(void)
{
        float f_num1 = 21.75;
        float f_num2 = 13.45;
        cout << "f_num1 =" << f_num1 << endl;
        cout << "f_num2 =" << f_num2 << endl;
        cout << "f_num1 + f_num2 =" << f_num1 + f_num2 << endl;
        return 0;
}

间接来看输入后果吧:

f_num1 = 21.75
f_num2 = 13.45
f_num1 + f_num2 = 35.2

很神奇是不是?因为这个后果看起来失常多了。
看到这里,置信咱们的心里都有老大一个疑难:为什么 C 程序和 C ++ 程序对同样的数字解决,输入的后果却不一样的?cout到底做了些什么?

cout 的神奇之处

为了验证 cout 对浮点数的解决,咱们无妨看一下上面的程序:

#include <iostream>
using namespace std;

int main(void)
{
        float num1 = 5;
        float num2 = 5.00;
        float num3 = 5.14;
        float num4 = 5.140000;
        float num5 = 5.123456;
        float num6 = 5.987654321;
        cout << "num1 =" << num1 << endl;
        cout << "num2 =" << num2 << endl;
        cout << "num3 =" << num3 << endl;
        cout << "num4 =" << num4 << endl;
        cout << "num5 =" << num5 << endl;
        cout << "num6 =" << num6 << endl;

        return 0;
}

看后果来剖析比拟直观,运行以上程序,后果如下:

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

num1num2num3num4 这两组后果能够晓得,cout对于 float 类型数值小数点前面的 0 是间接省去了的(这点和 C 语言格式化输入的 %g 有点像)。
num5num6两组后果不难剖析出,cout对于浮点型数值,最多保留 6 位有效数字。
以上是 cout 解决浮点数时的特点,应该记住。
事实上,咱们应用 iostream 库里的 cout.setf 不难使 cout 复原精度。咱们对下面的代码批改如下:

#include<iostream>
using namespace std;

int main(void)
{
        float f_num1 = 21.75;
        float f_num2 = 13.45;
        cout.setf(ios_base::fixed, ios_base::floatfield);       
        cout << "f_num1 =" << f_num1 << endl;
        cout << "f_num2 =" << f_num2 << endl;
        cout << "f_num1 + f_num2 =" << f_num1 + f_num2 << endl;
        return 0;
}

输入的后果就与 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 比特)来示意。一般来说,类型 floatdouble别离有 7 和 16 个无效位;类型 long double 则经常被用于有非凡浮点需要的硬件,它的具体实现不同,精度也各不相同。(《C++ Primer 第五版》

由以上形容,咱们不难晓得,对于 float 来说,最多只有 7 个无效位,这也就意味着,当理论存储的精度大于 float 的精度范畴时,就会呈现精度失落景象。
为了进一步佐证上述问题,咱们无妨将 float 的数值放大 10 亿倍,看看外面存储的值到底是多少:

#include<iostream>
using namespace std;

int main(void)
{
        float f_num1 = 21.75;
        float f_num2 = 13.45;
        cout.setf(ios_base::fixed, ios_base::floatfield);
        int billion = 1E9;
        float f_num10 = f_num1 * billion;
        float f_num20 = f_num2 * billion;
        cout << "f_num1 =" << f_num1 << endl;
        cout << "f_num2 =" << f_num2 << endl;

        cout << "f_num10 =" << f_num10 << endl;
        cout << "f_num20 =" << f_num20 << endl;
        return 0;
}

以上程序运行后果如下:

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,这样计算出来之后天然就会造成后果的不正确。

再看一个例子

咱们再来看一个精度失落造成运算后果不正确的例子。

#include<iostream>
using namespace std;

int main(void)
{
        float num1 = 2.3410E23;
        float num2 = num1 + 1.0f;
        cout << "num2 - num1 =" << num2 - num1 << endl;
        return 0;
}

如果精度不失落,运算后果应该为 1 才对,可是因为精度失落,导致最初的加 1 理论和没加成果一样,计算出来的后果是 0。

num2 - num1 = 0

怎么解决

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

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

比方 double 就比 float 精度要高,很多时候,应用 double 可能防止很多问题,比方本文一开始提到的问题,如果应用 double 就能完满解决:

#include <stdio.h>

int main(void)
{
        double f_num1 = 21.75;
        double f_num2 = 13.45;
        printf("f_num1 = %lf\n", f_num1);
        printf("f_num2 = %lf\n", f_num2);
        printf("f_num1 + f_num2 = %lf\n", f_num1 + f_num2);

        return 0;
}

大家能够本人运行一下看看后果。
double类型能够解决大部分精度失落问题,基本上满足日常应用了,然而依然不能防止精度失落(double也有精度限度),这时候就须要想另外的办法来解决了。

万能的 cout

后面提到过,cout其实是能够解决这种精度失落问题的,所以如果不是对效率要求过高或者要求格式化输入(其实 cout 也能够实现格式化输入,此处不具体开展)必须应用 printf,在编写 C ++ 程序时,倡议应用cout 代替printf

写在最初

本文只是简略的介绍了一下浮点型数值的精度问题,如果要深刻细究,必定不止这么多内容,比方浮点型数值在内存中是如何存储的?在字节里是如何散布 的?这才是真正外围的原理局部。在这里只浅尝辄止地讲述了一下,但置信阅读者曾经对精度问题有了一个初步的意识。

退出移动版