K＆R C章节练习int浮动吗？

Question

Section 1.3 of Kernighan and Ritchie uses the following temperature conversion program to introduce For statements:

#include <stdio.h>

/* print Fahrenheit-Celsius table */

int main(){

        int fahr;
        for (fahr = 0; fahr <= 300; fahr = fahr + 20)
            printf("%3d %6.1f\n", fahr, (5.0/9.0)*(fahr-32));
}

What it doesn't explain is how this program can make use of an int variable to produce float values without an error. What makes this valid? Don't all the variables in an equation have to be of the same type? I'm hesitant to move forward without understanding this.

Answer 1

The conversion are implicit, but enabling warnings should give you a message explaining that int is being converted to double.

Here (5.0/9.0)*(fahr-32)) , a double is being multiplied by an int, and the int is converted to double using usual arithmetic conversions.

The types in arithmetic don't necessarily have to match. C has a whole chapter dedicated to conversions: 6.3 Conversions, 6.3.1 Arithmetic operands.

Answer 2

Actually it doesn't: (5.0/9.0)*(fahr-32) is an expression of type double , not a float .

The reason being that 5.0 and 9.0 are double literals and the (fahr - 32) is promoted to that type before the multiplication takes place.

If you really want a float then use (5.0f/9.0f)*(fahr-32) . Note the suffixed f on the numbers (and you will need to suffix both).

%f is an appropriate format specifier in printf for a double and a float , so there are no problems there.

Answer 3

In an arithmetic expression, if two operands are of different types (such as int and double ), the operand with the lower precision will be converted to the same type as the operand with the higher precision. The exact rules can be found in section 6.3.1.8 of the online C 2011 standard .

Note that this only applies for arithmetic (integer and floating-point) types, not for pointer or aggregate types.

Answer 4

The reason an int can be promoted to a double without a problem -- assuming int represents a 32-bit integer and double represents a 64-bit IEEE floating point number, which is common -- is that a double has 53 bits of precision, so it has no trouble representing a 32-bit integer without loss. Any warning would just be informational and not a cause for concern, unlike when a 32-bit integer is coerced to a float , which only has 24 bits of precision and thus could lose up to eight bits (seven for a signed int ) of precision in the cast.