你不能用一个固定的。根据double的值，EPSILON会发生变化。

更好的双比较应该是:

bool same(double a, double b)
{
  return std::nextafter(a, std::numeric_limits<double>::lowest()) <= b
    && std::nextafter(a, std::numeric_limits<double>::max()) >= b;
}

'返回fabs(a - b) < EPSILON;

这是可以的，如果:

输入的数量级变化不大 极少数相反的符号可以被视为相等

否则就会给你带来麻烦。双精度数的分辨率约为小数点后16位。如果您正在比较的两个数字在量级上大于EPSILON*1.0E16，那么您可能会说:

return a==b;

我将研究一种不同的方法，假设您需要担心第一个问题，并假设第二个问题对您的应用程序很好。解决方案应该是这样的:

#define VERYSMALL  (1.0E-150)
#define EPSILON    (1.0E-8)
bool AreSame(double a, double b)
{
    double absDiff = fabs(a - b);
    if (absDiff < VERYSMALL)
    {
        return true;
    }

    double maxAbs  = max(fabs(a) - fabs(b));
    return (absDiff/maxAbs) < EPSILON;
}

这在计算上是昂贵的，但有时是需要的。这就是我们公司必须做的事情，因为我们要处理一个工程库，输入可能相差几十个数量级。

无论如何，关键在于(并且适用于几乎所有的编程问题):评估你的需求是什么，然后想出一个解决方案来满足你的需求——不要认为简单的答案就能满足你的需求。如果在您的评估后，您发现fabs(a-b) < EPSILON将足够，完美-使用它!但也要注意它的缺点和其他可能的解决方案。

General-purpose comparison of floating-point numbers is generally meaningless. How to compare really depends on a problem at hand. In many problems, numbers are sufficiently discretized to allow comparing them within a given tolerance. Unfortunately, there are just as many problems, where such trick doesn't really work. For one example, consider working with a Heaviside (step) function of a number in question (digital stock options come to mind) when your observations are very close to the barrier. Performing tolerance-based comparison wouldn't do much good, as it would effectively shift the issue from the original barrier to two new ones. Again, there is no general-purpose solution for such problems and the particular solution might require going as far as changing the numerical method in order to achieve stability.

以更一般的方式:

template <typename T>
bool compareNumber(const T& a, const T& b) {
    return std::abs(a - b) < std::numeric_limits<T>::epsilon();
}

注意: 正如@SirGuy所指出的，这种方法是有缺陷的。 我把这个答案留在这里，作为一个不遵循的例子。

不幸的是，即使您的“浪费”代码也是不正确的。EPSILON是可以添加到1.0并更改其值的最小值。值1.0非常重要——更大的数字在添加到EPSILON时不会改变。现在，您可以将这个值缩放到您正在比较的数字，以判断它们是否不同。比较两个双精度对象的正确表达式是:

if (fabs(a - b) <= DBL_EPSILON * fmax(fabs(a), fabs(b)))
{
    // ...
}

这是最小值。一般来说，你会想要在计算中考虑噪声，并忽略一些最不重要的位，所以更现实的比较应该是这样的:

if (fabs(a - b) <= 16 * DBL_EPSILON * fmax(fabs(a), fabs(b)))
{
    // ...
}

如果比较性能对您非常重要，并且您知道值的范围，那么您应该使用定点数字。

在这个版本中，你可以检查，这些数字之间的差异并不比某些分数(比如，0.0001%)更大:

bool floatApproximatelyEquals(const float a, const float b) {
    if (b == 0.) return a == 0.; // preventing division by zero
    return abs(1. - a / b) < 1e-6;
}

请注意Sneftel关于浮动可能的分数限制的评论。

还要注意的是，它不同于使用绝对的epsilon的方法——这里你不需要担心“数量级”——数字可能是，比如说1e100，或者1e-100，它们总是会被一致地比较，而且你不必为每一种情况更新epsilon。