我刚刚遇到了一个错误，我花了很长时间才弄清楚，这可能会给你一个浮点精度的好例子。

#include <iostream>
#include <iomanip>

int main(){
  for(float t=0;t<1;t+=0.01){
     std::cout << std::fixed << std::setprecision(6) << t << std::endl;
  }
}

输出为

0.000000
0.010000
0.020000
0.030000
0.040000
0.050000
0.060000
0.070000
0.080000
0.090000
0.100000
0.110000
0.120000
0.130000
0.140000
0.150000
0.160000
0.170000
0.180000
0.190000
0.200000
0.210000
0.220000
0.230000
0.240000
0.250000
0.260000
0.270000
0.280000
0.290000
0.300000
0.310000
0.320000
0.330000
0.340000
0.350000
0.360000
0.370000
0.380000
0.390000
0.400000
0.410000
0.420000
0.430000
0.440000
0.450000
0.460000
0.470000
0.480000
0.490000
0.500000
0.510000
0.520000
0.530000
0.540000
0.550000
0.560000
0.570000
0.580000
0.590000
0.600000
0.610000
0.620000
0.630000
0.640000
0.650000
0.660000
0.670000
0.680000
0.690000
0.700000
0.710000
0.720000
0.730000
0.740000
0.750000
0.760000
0.770000
0.780000
0.790000
0.800000
0.810000
0.820000
0.830000
0.839999
0.849999
0.859999
0.869999
0.879999
0.889999
0.899999
0.909999
0.919999
0.929999
0.939999
0.949999
0.959999
0.969999
0.979999
0.989999
0.999999

正如你所看到的，在0.83之后，精度显著下降。

然而，如果我将t设为双倍，这样的问题就不会发生。

我花了五个小时才意识到这个小错误，它毁了我的程序。

float类型，长度为32位，精度为7位。虽然它可以存储非常大或非常小的范围(+/- 3.4 * 10^38或* 10^-38)的值，但它只有7位有效数字。

类型double, 64位长，具有更大的范围(*10^+/-308)和15位精度。

类型long double名义上是80位，尽管给定的编译器/操作系统配对可能会将其存储为12-16字节以进行对齐。长双精度数的指数大得离谱，应该有19位精度。微软以其无限的智慧，将long double限制为8字节，与普通double相同。

一般来说，当需要浮点值/变量时，只需使用double类型。默认情况下，表达式中使用的字面浮点值将被视为双精度值，并且大多数返回浮点值的数学函数都会返回双精度值。如果只使用double，就可以省去很多麻烦和类型转换。

有三种浮点类型:

浮动 双 长两倍

一个简单的维恩图可以解释: 类型值的集合

给定二次方程:x2−4.0000000 x + 3.9999999 = 0, 10位有效数字的精确根为:r1 = 2.000316228, r2 = 1.999683772。

使用float和double，我们可以编写一个测试程序:

#include <stdio.h>
#include <math.h>

void dbl_solve(double a, double b, double c)
{
    double d = b*b - 4.0*a*c;
    double sd = sqrt(d);
    double r1 = (-b + sd) / (2.0*a);
    double r2 = (-b - sd) / (2.0*a);
    printf("%.5f\t%.5f\n", r1, r2);
}

void flt_solve(float a, float b, float c)
{
    float d = b*b - 4.0f*a*c;
    float sd = sqrtf(d);
    float r1 = (-b + sd) / (2.0f*a);
    float r2 = (-b - sd) / (2.0f*a);
    printf("%.5f\t%.5f\n", r1, r2);
}   

int main(void)
{
    float fa = 1.0f;
    float fb = -4.0000000f;
    float fc = 3.9999999f;
    double da = 1.0;
    double db = -4.0000000;
    double dc = 3.9999999;
    flt_solve(fa, fb, fc);
    dbl_solve(da, db, dc);
    return 0;
}  

运行程序得到:

2.00000 2.00000
2.00032 1.99968

注意，这些数字并不大，但是使用float仍然可以得到抵消效果。

(事实上，上面的方法并不是用单精度浮点数或双精度浮点数求解二次方程的最佳方法，但即使使用更稳定的方法，答案也不会改变。)

内置比较操作的不同之处在于，当你用浮点数比较两个数字时，数据类型的差异(即浮点数或双精度数)可能会导致不同的结果。

巨大的差异。

顾名思义，double的精度是浮点数[1]的2倍。一般来说，double有15个十进制数字的精度，而float有7个。

下面是如何计算位数的:

Double有52个尾数位+ 1个隐藏位:log(253)÷log(10) = 15.95位 浮点数有23个尾数位+ 1个隐藏位:log(224)÷log(10) = 7.22位数字

当重复计算时，这种精度损失可能导致更大的截断误差累积。

float a = 1.f / 81;
float b = 0;
for (int i = 0; i < 729; ++ i)
    b += a;
printf("%.7g\n", b); // prints 9.000023

而

double a = 1.0 / 81;
double b = 0;
for (int i = 0; i < 729; ++ i)
    b += a;
printf("%.15g\n", b); // prints 8.99999999999996

同样，float的最大值约为3e38，但double约为1.7e308，因此对于一些简单的事情，使用float可以比double更容易达到“无穷大”(即一个特殊的浮点数)，例如计算60的阶乘。

在测试期间，可能有一些测试用例包含这些巨大的数字，如果使用浮点数，可能会导致程序失败。

当然，有时，即使是双精度也不够精确，因此我们有时会有长双精度[1](上面的例子在Mac上给出了9.000000000000000066)，但所有浮点类型都有四舍五入错误，所以如果精度非常重要(例如货币处理)，你应该使用int或分数类。

此外，不要使用+=对大量浮点数求和，因为错误很快就会累积起来。如果使用Python，请使用fsum。否则，尝试实现Kahan求和算法。

[1]: C和c++标准没有指定float、double和long double的表示方式。这三种方法都有可能实现为IEEE双精度。然而，对于大多数架构(gcc, MSVC;x86, x64, ARM) float确实是IEEE单精度浮点数(binary32)， double是IEEE双精度浮点数(binary64)。