如何化简含小数的分数？C++浮点数误差的解决方法

原代码的核心问题在于二进制浮点数的精度局限性：像0.15、0.20这类十进制小数无法被二进制浮点数精确存储，导致后续的整数判断、乘法运算都会积累误差，最终转换为整数时出现偏差，让std::gcd返回1，无法正确约分。

具体来说：

• 0.15的二进制浮点数是近似值，永远无法通过乘2的幂次得到精确整数，isInt判断会一直为假，循环会持续到指数限制，生成超大浮点数；
• 超大浮点数转换为long long时，舍入误差会破坏原本的整数倍数关系，导致最大公约数计算错误。

要规避浮点数误差，核心是把浮点数转换为精确的整数分数后再处理，所有约分逻辑都基于整数运算。具体步骤：

1. 将输入的long double小数转换为整数形式的分子分母（处理精度误差）；
2. 对整数分数执行约分操作，利用整数的最大公约数（GCD）简化。

#include <cmath>
#include <cstdint>
#include <algorithm>

// 自定义GCD函数（兼容C++17之前的版本）
int64_t gcd(int64_t a, int64_t b) {
    a = std::abs(a);
    b = std::abs(b);
    while (b != 0) {
        int64_t temp = b;
        b = a % b;
        a = temp;
    }
    return a;
}

// 将long double转换为精确整数分数（允许微小精度误差）
void realToFraction(long double x, int64_t& num, int64_t& den) {
    if (x == 0.0L) {
        num = 0;
        den = 1;
        return;
    }

    // 处理符号
    int sign = (x > 0) ? 1 : -1;
    x = fabsl(x);

    // 用十进制缩放法转换：乘10直到小数部分接近0
    const long double eps = 1e-15L; // 匹配long double的精度
    int64_t power_of_10 = 1;
    long double scaled = x;
    while (fmodl(scaled, 1.0L) > eps && power_of_10 < 1e18) { // 防止整数溢出
        scaled *= 10.0L;
        power_of_10 *= 10;
    }

    num = static_cast<int64_t>(roundl(scaled)) * sign;
    den = power_of_10;
}

class Fraction {
public:
    int64_t numerator;
    int64_t denominator;

    // 从整数构造
    Fraction(int64_t num, int64_t den) : numerator(num), denominator(den) {
        normalize();
    }

    // 从long double小数构造
    Fraction(long double num_val, long double den_val) {
        int64_t n_num, n_den;
        int64_t d_num, d_den;
        realToFraction(num_val, n_num, n_den);
        realToFraction(den_val, d_num, d_den);

        // 分数除法转换为乘法：(n_num/n_den) / (d_num/d_den) = (n_num*d_den)/(n_den*d_num)
        numerator = n_num * d_den;
        denominator = n_den * d_num;
        normalize();
    }

    // 约分并确保分母为正
    void normalize() {
        if (numerator == 0) {
            denominator = 1;
            return;
        }
        int64_t common_divisor = gcd(numerator, denominator);
        numerator /= common_divisor;
        denominator /= common_divisor;

        if (denominator < 0) {
            numerator *= -1;
            denominator *= -1;
        }
    }
};

1. 浮点数转整数分数的精度处理：
   使用epsilon判断小数部分是否可忽略，避免因浮点数近似存储导致的无限循环；
   用roundl取整，减少舍入误差对整数转换的影响。

2. 全整数运算：
   约分逻辑完全基于int64_t整数，彻底规避浮点数运算的精度问题；
   自定义GCD函数，兼容不同C++版本。

3. 边界处理：
   处理0值、负数分母等边界情况，确保分数格式规范。

对于输入0.15/0.20，转换过程：

• 0.15 → 3/20，0.20 → 1/5；
• 分数运算后得到(3*5)/(20*1) = 15/20；
• 约分后得到3/4，完全符合预期。

• 如果输入是无理数（如sqrt(2)），无法转换为精确整数分数，需设置精度阈值生成近似分数；
• 若需处理超大数值，可将int64_t替换为__int128（编译器支持时）或使用第三方大数库（如GMP）；
• 浮点数转整数时需注意溢出风险，可根据业务场景调整power_of_10的上限。

内容的提问来源于stack exchange，提问作者hello there