C 表达式的计算顺序是什么

Question

int main(){
 char a = 5;
 float b = 6.0;
 int c = a + b;
 return c;
}

Looking at the generate instructions with gcc, the above code is evaluated like this:

• Load 5 and convert it to float as a
• Load 6 as b
• Add a and b
• Convert the result to an integer and return

Does gcc not care about the return type while it's dealing with the expression? It could have converted b to an int right off the bat as everything else is an integer type.

Is there a rule which explains how one side of an expression is evaluated first regardless of what the other side is?

Answer 1

You ask "Is there a rule?" Of course there is a rule. Any widely used programming language will have a huge set of rules.

You have an expression "a + b". a has type char, b has type float. There's a rule in the C language that the compiler has to find a common type and convert both to the common type. Since one of the values is a floating-point type, the common type must be a floating-point type, which is float, double, or long double. If you look closer at the rules, it turns out the common type must be float or double, and the compiler must document this. It seems the compiler chose "float" as the common type.

So a is converted from char to float, b is already float, both are added, the result has type float. And then there's a rule that to assign float to int, a conversion takes place according to very specific rules.

Any C compiler must follow these rules exactly. There is one exception: If the compiler can produce the results that it is supposed to produce then it doesn't matter how. As long as you can't distinguish it from the outside. So the compiler can change the whole code to "return 11;".

In the C language, partial expressions are evaluated without regard how they are used later. Whether a+b is assigned to an int, a char, a double, it is always evaluated in the same way. There are other languages with different rules, where the fact that a+b is assigned to an int could change how it is evaluated. C is not one of those languages.

Answer 2

If you change it to:

int main(){
 char a = 5;
 float b = 6.6;
 int c = a + 2*b;
 return c;
}

then it becomes clear that you have to keep the float 18.2 until the end.

With no optimizations, gcc acts as if this could happen and does a lot of conversions.

With just -O it already does the math itself and directly returns the final integer, even in above example.

There is no in-between reasoning and short-cut here. Why simplify from 5+6.0 to 5+6 but not to 11 ? Either act stupid and do cvtsi2ss xmm1,eax (and back etc.), or then tell them directly 11 .