双精度为64，单精度为64 (float)是32位。 double有一个更大的尾数(实数的整数位)。 任何不准确的地方都将在double中减小。

巨大的差异。

顾名思义，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)。

以下是标准C99 (ISO-IEC 9899 6.2.5§10)或c++ 2003 (ISO-IEC 14882-2003 3.1.9§8)标准所说的:

浮点数有三种类型:浮点数、双精度浮点数和长双精度浮点数。double类型提供的精度至少与float类型相同，long double类型提供的精度至少与double类型相同。float类型的值集是double类型值集的子集;double类型的值集是long double类型值集的子集。

c++标准增加了:

浮点类型的值表示是由实现定义的。

我建议你看一看优秀的《每个计算机科学家都应该知道浮点算术》，它深入介绍了IEEE浮点标准。您将了解表示细节，并将意识到在量级和精度之间存在权衡。浮点表示的精度随着幅度的减小而增加，因此-1到1之间的浮点数具有最高的精度。

在数量上，正如其他答案所指出的，不同之处在于double类型的精度是float类型的两倍，范围是float类型的三倍(取决于你如何计算)。

但也许更重要的是质的差异。float类型具有良好的精度，无论您正在做什么，这通常都足够好。另一方面，Type double具有出色的精度，无论你在做什么，它几乎总是足够好。

结果是，几乎总是应该使用类型double，这一点并不广为人知。除非你有一些特别的需要，否则你几乎不应该使用float类型。

As everyone knows, "roundoff error" is often a problem when you're doing floating-point work. Roundoff error can be subtle, and difficult to track down, and difficult to fix. Most programmers don't have the time or expertise to track down and fix numerical errors in floating-point algorithms — because unfortunately, the details end up being different for every different algorithm. But type double has enough precision such that, much of the time, you don't have to worry. You'll get good results anyway. With type float, on the other hand, alarming-looking issues with roundoff crop up all the time.

And the thing that's not necessarily different between type float and double is execution speed. On most of today's general-purpose processors, arithmetic operations on type float and double take more or less exactly the same amount of time. Everything's done in parallel, so you don't pay a speed penalty for the greater range and precision of type double. That's why it's safe to make the recommendation that you should almost never use type float: Using double shouldn't cost you anything in speed, and it shouldn't cost you much in space, and it will almost definitely pay off handsomely in freedom from precision and roundoff error woes.

(尽管如此，当你在微控制器上进行嵌入式工作或编写针对GPU优化的代码时，你可能需要float类型的“特殊需求”之一。在这些处理器上，double类型可能会非常慢，或者几乎不存在，所以在这种情况下，程序员通常会选择float类型来提高速度，并可能为精度付出代价。)

有三种浮点类型:

浮动 双 长两倍

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

给定二次方程: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仍然可以得到抵消效果。

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