浮点数精度丢失

#include <stdio.h>

int main() {
    // 直接比较（会输出0，即False）
    printf("0.1 + 0.2 == 0.3  => %d\n", 0.1 + 0.2 == 0.3);

    // 打印实际计算结果
    printf("0.1 + 0.2 = %.17g\n", 0.1 + 0.2);
    
    return 0;
}

输出结果：

0.1 + 0.2 == 0.3  => 0
0.1 + 0.2 = 0.30000000000000004

为什么？

十进制 0.1 的二进制是无限循环小数：
0.1（十进制） = 0.00011001100110011...（二进制），就像十进制的 1/3 = 0.3333...。
计算机只能存储有限位数：比如单精度（float）只能存23位尾数，双精度（double）存52位。
结果：存储时会“四舍五入”，导致微小误差。

三、图解浮点数的存储（以0.1为例）

以 32位单精度（float） 存储 0.1：

二进制表示：0.00011001100110011001101...（无限循环）。
IEEE 754 存储：
- 符号位：0（正数）
- 指数位：调整到规格化形式（类似科学计数法）
- 尾数位：只能保留23位，后面的位数被截断。

实际存储的值 ≈ 0.10000000149011612（十进制），而不是精确的0.1！

四、哪些操作容易导致精度问题？

小数相加/相减：尤其是不同数量级的数相加（如 1000000.0 + 0.0000001）。
多次累积计算：误差会逐步放大（如循环累加0.1十次可能不等于1.0）。
强制类型转换：如将大范围的浮点数转为整数时。

五、如何避免精度问题？

方法1：使用整数代替浮点数

适用场景：处理货币、精确计数（例如以“分”为单位存储金额）。

#include <stdio.h>

// 用整数表示金额（单位：分）
int main() {
    int price_cents = 10 + 20; // 0.10元 + 0.20元 = 0.30元（用分计算）
    printf("总金额：%d 分（即 %.2f 元）\n", price_cents, price_cents / 100.0);
    return 0;
}

输出结果：

总金额：30 分（即 0.30 元）

方法2：比较浮点数时使用误差范围

不要直接写 a == b，而是判断两者差值是否在允许范围内。

#include <stdio.h>
#include <math.h> // 需要链接数学库（编译时加 -lm）

// 判断两个浮点数是否近似相等
int is_float_equal(double a, double b, double epsilon) {
    return fabs(a - b) < epsilon;
}

int main() {
    double result = 0.1 + 0.2;
    double expected = 0.3;

    // 直接比较（错误！）
    printf("直接比较：%d\n", (result == expected)); // 输出 0（False）

    // 使用误差范围比较（正确）
    printf("误差比较：%d\n", is_float_equal(result, expected, 1e-9)); // 输出 1（True）
    return 0;
}

编译命令：

gcc -o test test.c -lm

方法3：使用高精度库

C 语言没有内置定点数类型，但可通过整数模拟：

#include <stdio.h>

// 定义定点数类型（保留4位小数）
typedef long long fixed_point;
#define SCALE_FACTOR 10000 // 10^4

int main() {
    // 0.1 表示为 0.1 * 10000 = 1000
    fixed_point a = 1000; 
    fixed_point b = 2000; // 0.2
    fixed_point sum = a + b; // 0.3 → 3000

    // 转换为浮点数显示
    printf("结果：%.4f\n", sum / (double)SCALE_FACTOR); // 输出 0.3000
    return 0;
}

优点：避免浮点数误差，适合需要确定精度的场景。

方法4：避免不必要的计算

减少中间步骤：复杂的公式尽量合并计算步骤。

#include <stdio.h>

int main() {
    double big_num = 1e16;
    double small_num = 1.0;

    // 错误顺序：大数 + 小数 → 小数被忽略
    printf("错误顺序：%d\n", (big_num + small_num) == big_num); // 输出 1（True）

    // 正确顺序：先加小数再加大数（但此处依然可能丢失精度）
    // 更优方案：重新设计算法，避免混合悬殊量级的运算
    return 0;
}