关于C ++中double和int之间转换的奇怪结果

Question

My Problem:

Try to figure out the result of the following C++ snippet:

#include <iostream>

int main(int argc, char* argv[])
{
    double a = 5.1;
    int b = a * 100;
    std::cout << b << std::endl;

    double c = 6.1;
    int d = c * 100;
    std::cout << d << std::endl;
}

On Windows, I compiled and run the above code with VS2008 SP1 and get:

509
610

While on Linux, I compiled and run the same code with g++ and get:

509
609

What is the problem of the code?

Sorry I have tried to figure a title for the problem thus I could have searched around. However, I can't name this problem, so I directly present it here.

Any advice is appreciated.

Answer 1

double is not an exact type, as you can see by applying the std::numeric_limits typetrait :

#include <limits>

static_assert(std::numeric_limits<double>::is_exact == false);

Thus computations involving doubles are only approximate, and there is nothing wrong about what you observe.

There is no problem with your code.

Answer 2

In general, with double (and float) being binary, you can only ever make precise representations of fractions of powers of 2. Thus, if the decimal part is only made up of terms like 1/2, 1/4, 1/8, 1/16 etc. a float or double will be exact (unless you run into precision problems, of course).

Now, "0.1" is 1/10, which is actually 1/2 * 1/5. 5 is not a power of two, thus "0.1" can't be represented in binary, it can only be approximated.

Answer 3

double to int conversion is done by truncation unless otherwise specified. In your case, due to loss of precisions while rounding the numbers (and a small amount of bad luck as noted by MSalters since this only happens near some "edge" values).

Here are few possible reasons for the difference in behaviour between compilers/OS:

• Optimizations: some compilers implement compile time floating operation with infinite precision. Since your code is simple it is possible for the compiler to do the computation at compile time with infinite precision. (Have you checked the generated ASM code ?)
• Using different internal representation. Since you are running windows you are using an x86 or an x86-64 CPU that implements floating points with more than 64 bits see this for some details.
• Use of a different architecture entirely (are both your OS 64 bit ?)

Answer 4

As one of the rules of The elements of programming styles by Kernighan and Plauger stated.

10.0 times 0.1 is hardly ever 1.0

Meaning that floats don't behave like mathematical real numbers. There is a standard (IEEE 754) how you can implement floats but its not part of the C standard but only in C#.