C中的浮点评估顺序

Question

I am using Code::Blocks 10.05 on Windows 7.

I have compiled the following program,

#include<stdio.h>

int main()
{
 float f=1.5;
 printf("%f\n",(f-1)*1/2);
 return 0;
}

The output was 0.250000 . I understand it as follows,

Since f is a float (f-1) returns a float value of 0.500000 and the whole expression is upgraded to floating point arithmetic and hence 1/2 is also treated as float to get 0.500000 and hence the result.

Also the following statement,

 float f=1.5;
 printf("%f\n",1/2*(f-1));

gave 0.000000 as answer. Here the expression 1/2 performed integer division. Here I expected (f-1) to be evaluated first and the whole expression to be upgraded to floating point arithmetic.

Here again I thought since the Polish notation is,

* / 1 2 - f 1

division is the first operation performed and hence the result. Am I correct about this assumption?

Finally the following statement defies all the logic,

 float f=1.5;
 printf("%f\n",(f-1)*(1/2));

The output is 0.000000 , But here the Polish notation is,

* - f 1 / 1 2 

So (f-1) ought to be evaluated first and hence the whole expression upgrades to floating point arithmetic and the output should be 0.250000 .

Where did I go wrong? Does this have something to do with evaluation order of the operator *? Is the expression ambiguous in C?

Answer 1

Since f is a float (f-1) returns a float value of 0.500000 and the whole expression is upgraded to floating point arithmetic

No, where did you get that misinformation from? Promotion to floating-point only applies to the one operator of which either operand is a floating-point number. 1/2 is not treated as a floating-point expression -- as such, it's not even evaluated. Since multiplication and division have the same precedence and are left-associative,

(f - 1) * 1 / 2

is evaluated as

((f - 1) * 1) / 2)

And there, 1 is promoted to float (at least), and then because ((f - 1) * 1) is floating-point as well, then the other operand of the division, 2 is also promoted to float (or a higher precision FP number, depending on what the compiler wants).

Here I expected (f-1) to be evaluated first and the whole expression to be upgraded to floating point arithmetic.

No, that's an incorrect expectation, as I just explained. It's not the full expression that is subject to conversion to floating-point. It's only the other immediate operand of the operator of which the one operand is a float . Hence in the expression:

(f - 1) * (1 / 2)

f - 1 is a float . 1 / 2 is an integer, it is zero, and then the integer zero is promoted to float because the other operand of * is a float . The operands of / , however, are integers, so the division is evaluated according to the rules of integer arithmetic.

Answer 2

* and / have the same precedence, so (f-1)*1/2 is equivalent to ((f-1)*1)/2 , not what you think it is.

While 1/2*(f-1) is equivalent to (1/2)*(f-1) in which 1/2 has the value of 0 .

Answer 3

Because of the paranthesis: (1/2) you only get a big zero (the result of 1/2) upgraded to a float. Hence the zero result.

Answer 4

(1/2) is treated as integer and results zero. Multiplication by zero leads result which is also zero.

Answer 5

The expression is evaluated from left to right:

• The expression f is a float .
• In the expression f - 1 both operands are promoted to double , the value is 0.5 . Call the expression E1 .
• Same for (f - 1) * 1 , which is E1 * 1 , both operands are promoted to double and the value of the expression is 0.5 . Call the expression E2 .
• Same for (f - 1) * 1 / 2 , which is E2 / 2 , both operands are promoted to double and the value of th eexpression is 0.25 .