C++函数返回double值异常求助：大数运算丢失小数位

Let's break down what's going on with your function and how to fix it for good.

The Root Cause #

First off, your original function logic is mathematically correct:

double foo(int a, int b) { double r=a+b; return r/2.0; }

When you pass a=100000 and b=100001, it should compute 200001.0 / 2 = 100000.5—a value that double can represent exactly (since double has 53 bits of precision, which can handle all integers up to ~9 quadrillion perfectly).

The odd behavior you're seeing is almost certainly due to one of two things:

• Output precision limitations: Your function is actually returning 100000.5, but the default output format (like C++ cout's default 6 significant digits) is truncating or rounding the value when displayed. For example, 100000.5 has 7 significant digits, so default output might round it to 100001 or display it in scientific notation, but in your environment it's being truncated to 100000.
• Integer overflow (rare today): If you're using an ancient compiler that uses 16-bit int types (max value 32767), 100000 and 100001 would overflow the int range, leading to garbage values for a+b and thus wrong averages. This is extremely uncommon with modern compilers, though.

Your attempt to cast a+b to double didn't change anything because the problem wasn't in the cast—it was either in how the result was displayed, or a potential overflow risk that hasn't hit your test cases yet.

The Fix: Avoid Overflow and Ensure Precision #

Since you can't control how the output is handled, the best approach is to modify your function to eliminate any possible integer overflow (which would break the calculation entirely for very large int values) while keeping the result mathematically identical.

Here are two robust options:

Option 1: Cast One Operand Before Adding #

By casting one int to double first, you force the entire addition to happen in floating-point, avoiding integer overflow entirely:

double foo(int a, int b) {
    return (static_cast<double>(a) + b) / 2.0;
}

Option 2: Calculate Halves Separately #

This is even more explicit, and mathematically identical to the original logic:

double foo(int a, int b) {
    return static_cast<double>(a) / 2.0 + static_cast<double>(b) / 2.0;
}

Both versions will return the exact 100000.5 for your test case, and they'll handle much larger int values without overflowing. The result will be a perfectly precise double value that any correct output method can display accurately if given enough precision.

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