C ++：编译器是否优化整数+浮点算术运算？

Question

Are compilers empowered or even capable of optimizing arithmetic operations where one side is an integer type, while the other is a float? Or will the integer just be promoted to a float before performing the operation in 100% of the cases?

The reason I ask is because I like to perform the float promotion myself for clarity, but I might stop doing so if it preserves a situation the compiler can capitalize on.

Answer 1

In cases where a compiler can optimize an addition between a float and an integer, such as optimizing 3.f + 1 to 4 rather than performing the addition at run-time, I would expect the presence of a cast to have no effect on whether the compiler can optimize.

This is a general statement, based upon how modern compilers work, not a logical necessity. In circumstances where a compiler recognizes that some f + i can be optimized, for some float f and some integer i (possibly constants or expressions, not just identifiers), then f + (float) i should be equivalent in the compiler's analysis and should receive the same optimization.

One way to understand why this is is that, in parsing f + i , the compiler will recognize that i must be converted to float , and it will construct, in its internal representation of the program, statements to get f , get i , convert i to float , and add them. When analyzing f + (float) i , the same internal representation will be constructed, so the two statements will be equivalent.

That said, I expect cases where the compiler can optimize may be fairly limited. Compilers may recognize specific situations such as adding two constants, adding a float zero to an integer, and adding an integer zero to a float . Sometimes the compiler might be able to deduce values for f and i even if they are expressions or identifiers, rather than constants, because the flow of prior code necessarily produces some value, and then it might be able to optimize based on the deduced values.

So, special cases may be recognized. I would not expect the compiler to be able to generally turn f + i into any sort of optimized bit-twiddling that would be faster than a floating-point add (or whatever instruction the compiler would normally use). However, in theory, it could happen, and, if so, a well-designed compiler ought to optimize f + i the same as f + (float) i . (Perhaps there are C implementations with floating-point support in software instead of hardware that might handle an add of a floating-point value and an integer in a faster way than an add of two floating-piont values.)

Answer 2

I was curious too so I've done some quick tests and I've observed the following behaviors:

The execution time of this fragment of code was:

for (int i = 0; i < 1000000000; ++i) {
    f = f + 1;
}

• Without -O2 flag: 2156.25 ms
• With -O2 flag: 953.125 ms

And with a float promotion:

for (int i = 0; i < 1000000000; ++i) {
    f = f + (float)1;
}

• Without -O2 flag: 2156.25 ms
• With -O2 flag: 968.75 ms

This is just one circumstance. Surely this is not the best way to check and i'm sure the compiler could do it better or worse depending on the situation but I observed a little difference in time with optimitzation O2.

**Runs were made in c++11. CPU architecture: AMD64**