关于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_num1和 f_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

从 num1 和num2，num3和 num4 这两组后果能够晓得，cout对于 float 类型数值小数点前面的 0 是间接省去了的（这点和 C 语言格式化输入的 %g 有点像）。
从 num5 和num6两组后果不难剖析出，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 比特）来示意。一般来说，类型 float 和double别离有 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。

写在最初

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