正如 Alexandre C. 解释的那样，IEEE doubles 有一个 53 位尾数（存储 52 位，隐含最高位），浮点数有 24 位（存储 23 位，隐含最高位）。
编辑：（感谢反馈，我希望这更清楚）
当整数转换为双精度 double f = (double)1024; 时，该数字以适当的指数 (1023+10) 保存，并且 same 位模式有效地存储为原始整数（实际上IEEE二进制浮点不存储最高位。IEEE浮点数被“标准化”为最高位= 1，通过调整指数，然后顶部1被修剪掉，因为它是“隐含”的，这样可以节省一点存储）。
一个 32 位整数将需要一个双精度来完美地保存它的值，而一个 8 位整数将完美地保存在一个浮点数中。那里没有信息丢失。它可以无损失地转换回整数。损失发生在算术和小数值上。
除非代码这样做，否则整数不会映射到 +/-1。当代码将存储为双精度的 32 位整数除以将其映射到范围 +/-1 时，很可能会引入错误。
映射到 +/-1 会降低 53 位精度，但错误只会出现在最低位，远低于原始整数所需的 32 位。后续操作也可能会丢失精度。例如，将两个数字与超过 53 位精度的结果范围相乘会丢失一些位（即，将两个数字与尾数的超过 27 个有效位相乘）。
可能有用的浮点解释是"What Every Computer Scientist Should Know About Floating-Point Arithmetic" 它解释了浮点数的一些反直觉（对我而言）行为。
例如，数字 0.1不能精确地保存在 IEEE 二进制浮点双精度数中。
这个程序可能会帮助您了解正在发生的事情：
/* Demonstrate IEEE 'double' encoding on x86
* Show bit patterns and 'printf' output for double values
* Show error representing 0.1, and accumulated error of adding 0.1 many times
* G Bulmer 2012
*/
#include <stdio.h>
typedef struct {
unsigned long long mantissa :52;
unsigned exponent :11;
unsigned sign :1;
} double_bits;
const unsigned exponent_offset = 1023;
typedef union { double d; unsigned long long l; double_bits b; } Xlate;
void print_xlate(Xlate val) {
const long long IMPLIED = (1LL<<52);
if (val.b.exponent == 0) { /* zero? */
printf("val: d: %19lf bits: %016llX [sign: %u exponent: zero=%u mantissa: %llX]\n",
val.d, val.l, val.b.sign, val.b.exponent, val.b.mantissa);
} else {
printf("val: d: %19lf bits: %016llX [sign: %u exponent: 2^%4-d mantissa: %llX]\n",
val.d, val.l, val.b.sign, ((int)val.b.exponent)-exponent_offset,
(IMPLIED|val.b.mantissa));
}
}
double add_many(double d, int many) {
double accum = 0.0;
while (many-- > 0) { /* only works for +d */
accum += d;
}
return accum;
}
int main (int argc, const char * argv[]) {
Xlate val;
val.b.sign = 0;
val.b.exponent = exponent_offset+1;
val.b.mantissa = 0;
print_xlate(val);
val.d = 1.0; print_xlate(val);
val.d = 0.0; print_xlate(val);
val.d = -1.0; print_xlate(val);
val.d = 3.0; print_xlate(val);
val.d = 7.0; print_xlate(val);
val.d = (double)((1LL<<31)-1LL); print_xlate(val);
val.d = 2147483647.0; print_xlate(val);
val.d = 10000.0; print_xlate(val);
val.d = 100000.0; print_xlate(val);
val.d = 1000000.0; print_xlate(val);
val.d = 0.1; print_xlate(val);
val.d = add_many(0.1, 100000);
print_xlate(val);
val.d = add_many(0.1, 1000000);
print_xlate(val);
val.d = add_many(0.1, 10000000);
print_xlate(val);
val.d = add_many(0.1,10); print_xlate(val);
val.d *= 2147483647.0; print_xlate(val);
int i = val.d; printf("int i=truncate(d)=%d\n", i);
int j = lround(val.d); printf("int i=lround(d)=%d\n", j);
val.d = add_many(0.0001,1000)-0.1; print_xlate(val);
return 0;
}
输出是：
val: d: 2.000000 bits: 4000000000000000 [sign: 0 exponent: 2^1 mantissa: 10000000000000]
val: d: 1.000000 bits: 3FF0000000000000 [sign: 0 exponent: 2^0 mantissa: 10000000000000]
val: d: 0.000000 bits: 0000000000000000 [sign: 0 exponent: zero=0 mantissa: 0]
val: d: -1.000000 bits: BFF0000000000000 [sign: 1 exponent: 2^0 mantissa: 10000000000000]
val: d: 3.000000 bits: 4008000000000000 [sign: 0 exponent: 2^1 mantissa: 18000000000000]
val: d: 7.000000 bits: 401C000000000000 [sign: 0 exponent: 2^2 mantissa: 1C000000000000]
val: d: 2147483647.000000 bits: 41DFFFFFFFC00000 [sign: 0 exponent: 2^30 mantissa: 1FFFFFFFC00000]
val: d: 2147483647.000000 bits: 41DFFFFFFFC00000 [sign: 0 exponent: 2^30 mantissa: 1FFFFFFFC00000]
val: d: 10000.000000 bits: 40C3880000000000 [sign: 0 exponent: 2^13 mantissa: 13880000000000]
val: d: 100000.000000 bits: 40F86A0000000000 [sign: 0 exponent: 2^16 mantissa: 186A0000000000]
val: d: 1000000.000000 bits: 412E848000000000 [sign: 0 exponent: 2^19 mantissa: 1E848000000000]
val: d: 0.100000 bits: 3FB999999999999A [sign: 0 exponent: 2^-4 mantissa: 1999999999999A]
val: d: 10000.000000 bits: 40C388000000287A [sign: 0 exponent: 2^13 mantissa: 1388000000287A]
val: d: 100000.000001 bits: 40F86A00000165CB [sign: 0 exponent: 2^16 mantissa: 186A00000165CB]
val: d: 999999.999839 bits: 412E847FFFEAE4E9 [sign: 0 exponent: 2^19 mantissa: 1E847FFFEAE4E9]
val: d: 1.000000 bits: 3FEFFFFFFFFFFFFF [sign: 0 exponent: 2^-1 mantissa: 1FFFFFFFFFFFFF]
val: d: 2147483647.000000 bits: 41DFFFFFFFBFFFFF [sign: 0 exponent: 2^30 mantissa: 1FFFFFFFBFFFFF]
int i=truncate(d)=2147483646
int i=lround(d)=2147483647
val: d: 0.000000 bits: 3CE0800000000000 [sign: 0 exponent: 2^-49 mantissa: 10800000000000]
这表明完整的 32 位 int 被精确表示，而 0.1 则不是。它表明 printf 不精确打印浮点数，而是四舍五入或截断（要警惕的事情）。它还说明了 0.1 表示中的错误量在 1,000,000 次加法操作中没有累积到足够大的值以导致 printf 打印它。它表明可以通过舍入来恢复原始整数，但不能通过赋值来恢复，因为赋值会截断。它表明减法运算可以“放大”错误（减法后剩下的都是错误），因此应该仔细分析算术。
把它放到音乐环境中，采样率可能是 96KHz。在错误累积到足以导致前 32 位包含超过 1 位错误之前，需要 10 秒以上的添加。
进一步。创建 Ogg 和 Vorbis 的 Christopher “Monty” Montgomery 在一篇关于音乐、采样率和采样分辨率的文章中认为，对于音频来说，24 位应该绰绰有余24/192 Music Downloads ...and why they make no sense
总结
double 完美地保存 32 位整数。有 N/M 形式的有理十进制数（其中 M 和 N 可以用 32 位整数表示）可以不用二进制小数位的有限序列表示。因此，当一个整数映射到范围 +/-1 并因此转换为有理数 (N/M) 时，某些数字不能用双精度小数部分中的有限位数表示，因此错误会蔓延在。
这些错误通常非常小，在最低位中，因此远低于高 32 位。所以它们可以通过四舍五入在整数和双精度之间来回转换，双精度表示的错误不会导致整数错误。但是，算术可以改变错误。不正确构造的算术会导致错误迅速增长，并可能增长到原始整数值已损坏的程度。
其他想法：
如果精度很重要，还有其他方法可以使用双精度数。它们都不像映射到 +/-1 那样方便。我能想到的一切都需要跟踪算术运算，这最好使用 C++ 包装类来完成。这会大大减慢计算速度，因此可能毫无意义。
这是一种非常狡猾的'Automatic Diferentiation' 方法，方法是将算术包装在跟踪额外信息的类中。我认为那里的想法可能会激发一种方法。它甚至可能有助于确定精度丢失的位置。