How small is "small enough" should be determined by the specific problem being dealt with. For example, using double表示金额的话，1e-4就可以认为是零了。而如果进行科学计算，恐怕1e-7 is too big.

<cfloat>中有定义DBL_EPSILON为与1.0The closest difference. See here.

The comparison of floating point numbers still needs to be based on actual storage rules, because floating point numbers are stored in binary, and using binary to represent decimal cannot be accurately represented. Even if the decimal significant digits of floating point numbers are relatively small, it may not be possible. Exactly represented in binary . why?
First of all, the binary representation of the decimal places of floating point numbers is as follows:
1 decimal place: 0.5 (2^-1)
2 decimal places: 0.25 (2^-2)
...
n decimal places: 2 ^-n
In other words, the decimal part of any floating-point number is composed of 2^-1...2^-n, so you can understand why floating-point numbers with few significant digits cannot If it is accurately expressed, for example, 0.3, it cannot be accurately expressed using the above combination of digits. If you don’t believe in cout, try it:

#include <iostream>
#include <iomanip>

int main()
{
    float a = 0.3f;
    std::cout << std::setprecision(32) << a << std::endl;
    return 0;
}

Output: 0.30000001192092896
And if you replace 0.3 with 0.5, that’s fine, because 0.5 can be accurately represented by 2^-1! In the same way, 0.625 is also OK.
Then why can we usually output 0.3 directly when cout << 0.3? That's because cout performs rounding processing by default.

Back to the original poster's question: If you directly judge 0.3 == 0.3, that's no problem, because the same number has the same representation, so you can use '==' directly. This is especially true if it is a number that can be represented accurately, such as 0.
But if you want to judge whether 0.1+0.2 and 0.3 are equal, it won’t work, because they both have accuracy loss, and the loss values ​​are different, so you can’t directly compare and you need to use a method like abs((0.1+0.2) - 0.3)<EPSILON.

Computer representation of floating-point numbers (float or double type) has a precision limit. For floating-point numbers that exceed the precision limit, the computer will truncate the decimal part beyond their precision. Therefore, two floating point numbers that are originally unequal may become equal in the computer. For example:

float a=10.222222225，b=10.222222229
数学上a和b是不相等的，但在32位计算机中它们是相等的。

如果两个同符号浮点数之差的绝对值小于或等于某一个可接受的误差(即精度)，就认为它们是相等的。
不要直接用“==”或者“!=”对两个浮点数进行比较，但是可以直接用“<”和“>”比较谁大谁小。