有关更深入的方法，请参阅比较浮点数。以下是该链接的代码片段:

// Usable AlmostEqual function    
bool AlmostEqual2sComplement(float A, float B, int maxUlps)    
{    
    // Make sure maxUlps is non-negative and small enough that the    
    // default NAN won't compare as equal to anything.    
    assert(maxUlps > 0 && maxUlps < 4 * 1024 * 1024);    
    int aInt = *(int*)&A;    
    // Make aInt lexicographically ordered as a twos-complement int    
    if (aInt < 0)    
        aInt = 0x80000000 - aInt;    
    // Make bInt lexicographically ordered as a twos-complement int    
    int bInt = *(int*)&B;    
    if (bInt < 0)    
        bInt = 0x80000000 - bInt;    
    int intDiff = abs(aInt - bInt);    
    if (intDiff <= maxUlps)    
        return true;    
    return false;    
}

这个怎么样?

template<typename T>
bool FloatingPointEqual( T a, T b ) { return !(a < b) && !(b < a); }

我见过各种方法，但从来没有见过这个，所以我也很好奇听到任何评论!

/// testing whether two doubles are almost equal. We consider two doubles
/// equal if the difference is within the range [0, epsilon).
///
/// epsilon: a positive number (supposed to be small)
///
/// if either x or y is 0, then we are comparing the absolute difference to
/// epsilon.
/// if both x and y are non-zero, then we are comparing the relative difference
/// to epsilon.
bool almost_equal(double x, double y, double epsilon)
{
    double diff = x - y;
    if (x != 0 && y != 0){
        diff = diff/y; 
    }

    if (diff < epsilon && -1.0*diff < epsilon){
        return true;
    }
    return false;
}

我在我的小项目中使用了这个函数，它是有效的，但注意以下几点:

双精度误差可以为你制造惊喜。假设epsilon = 1.0e-6，那么根据上面的代码，1.0和1.000001不应该被认为是相等的，但在我的机器上，函数认为它们是相等的，这是因为1.000001不能精确地转换为二进制格式，它可能是1.0000009xxx。我用1.0和1.0000011测试了它，这次我得到了预期的结果。

正如其他人所指出的那样，使用固定指数(例如0.0000001)对于远离该值的值是无用的。例如，如果你的两个值是10000.000977和10000，那么这两个数字之间没有32位浮点值——10000和10000.000977是你可能得到的最接近的值，而不是位对位相同。这里，小于0.0009是没有意义的;你也可以使用直接等式运算符。

同样地，当两个值的大小接近ε时，相对误差增长到100%。

Thus, trying to mix a fixed point number such as 0.00001 with floating-point values (where the exponent is arbitrary) is a pointless exercise. This will only ever work if you can be assured that the operand values lie within a narrow domain (that is, close to some specific exponent), and if you properly select an epsilon value for that specific test. If you pull a number out of the air ("Hey! 0.00001 is small, so that must be good!"), you're doomed to numerical errors. I've spent plenty of time debugging bad numerical code where some poor schmuck tosses in random epsilon values to make yet another test case work.

如果你从事任何类型的数值编程，并认为你需要达到定点的epsilon，请阅读BRUCE关于比较浮点数的文章。

浮点数比较

Qt实现了两个函数，也许你可以从中学到一些东西:

static inline bool qFuzzyCompare(double p1, double p2)
{
    return (qAbs(p1 - p2) <= 0.000000000001 * qMin(qAbs(p1), qAbs(p2)));
}

static inline bool qFuzzyCompare(float p1, float p2)
{
    return (qAbs(p1 - p2) <= 0.00001f * qMin(qAbs(p1), qAbs(p2)));
}

您可能需要以下函数，因为

请注意，比较p1或p2为0.0的值是无效的， 也不会比较其中一个值为NaN或无穷大的值。 如果其中一个值总是0.0，则使用qFuzzyIsNull代替。如果一个人 其中的值很可能是0.0，一种解决方案是将两者都加上1.0 值。

static inline bool qFuzzyIsNull(double d)
{
    return qAbs(d) <= 0.000000000001;
}

static inline bool qFuzzyIsNull(float f)
{
    return qAbs(f) <= 0.00001f;
}

在数值软件中，确实有这样的情况，你需要检查两个浮点数是否完全相等。我就一个类似的问题发表了这篇文章

https://stackoverflow.com/a/10973098/1447411

所以你不能说“CompareDoubles1”是错误的。