C++中double与int不能直接比较？VS可运行及间接方式是否为隐式转换疑问

Great question! Let's unpack this step by step because it's a super common point of confusion for C++ learners.

Why does the book say "you can't directly compare double and int"? #

First off, this isn't a syntax rule—C++ doesn't forbid writing code like if (my_double == my_int). What the book is warning about is logical pitfalls rooted in how floating-point numbers (like double) work:

• Floating-point types have limited precision. Integers larger than 2^53 can't be represented exactly as a double (since double uses 53 bits for the mantissa). So if you have an int like 9007199254740993, converting it to double will lose precision, and comparing the original int to the converted double will give a false result even though you'd expect them to be equal.
• Even for smaller values, operations on doubles can introduce tiny precision errors. For example, 0.1 + 0.2 doesn't equal exactly 0.3 as a double—direct equality checks here will fail unexpectedly.

The book's advice is a warning against relying on direct equality between double and int because it can lead to bugs that are hard to spot.

Why does Visual Studio let this run without errors? #

Because the C++ standard allows this comparison! When you write double == int, the compiler performs an implicit conversion: it automatically converts the int to a double, then compares two double values. This is syntactically valid, so Visual Studio (or any standard-compliant compiler) won't throw an error by default.

If you turn up your warning level (e.g., using /W4 in Visual Studio), you might get a warning about implicit conversion, but it won't block compilation. The book's "can't directly compare" is a best practice, not a hard compiler rule.

Is the "indirect method" mentioned in the book implicit conversion? #

Nope—implicit conversion is exactly what's happening when you do the "direct" comparison the book warns against. The "indirect methods" refer to ways to compare safely by accounting for floating-point precision issues. Common examples include:

• Comparing the absolute difference between the double and the converted int to a small epsilon (a tiny value like 1e-9). This checks if they're "close enough" rather than exactly equal:

  #include <cmath>
  
  double d = some_value;
  int i = another_value;
  if (std::abs(d - i) < 1e-9) {
      // Treat them as equal
  }
  

• Explicitly converting the double to an int (with caution!) if you know the double should represent an integer value (e.g., static_cast<int>(d) == i). But beware: this truncates decimal values, so it only works if you're sure the double is an integer.

Example of the pitfall vs. safe comparison #

#include <iostream>
#include <cmath>

int main() {
    // Pitfall: Direct comparison fails due to precision loss
    int large_int = 9007199254740993;
    double converted_double = large_int;
    std::cout << "Direct comparison result: " << (large_int == converted_double) << "\n"; // Outputs 0 (false)

    // Safe indirect comparison
    double sum = 0.1 + 0.2;
    if (std::abs(sum - 0.3) < 1e-9) {
        std::cout << "Sum is approximately equal to 0.3\n"; // Outputs this line
    }

    return 0;
}

内容的提问来源于stack exchange，提问作者sangmin park