simple question about assigning float to int

Question

This is probably something very simple but I'm not getting the results I'm expecting. I apologise if it's a stupid question, I just don't what to google for.

Easiest way to explain is with some code:

int var = 2.0*4.0;

NSLog(@"%d", 2.0*4.0);//1
NSLog(@"%d", var);//2

if ((2.0*4.0)!=0) {//3
    NSLog(@"true");
}

if (var!=0) {//4
    NSLog(@"true");
}

This produces the following output:

0   //1
8   //2
true    //3
true    //4

The one that I don't understand is line //1. Why are all the others converting (I'm assuming the correct word is "casting", please correct me if I'm wrong) the float into an int, but inside NSLog it's not happening. Does this have something to do with the string formatting %d parameter and it being fussy (for lack of a better word)?

Answer 1

The format string %d expects a decimal number, meaning a base 10 integer, not a floating point. What you want there is %f if you're trying to get it to print out 8.0

Answer 2

You're telling NSLog that you're passing it an integer with the @"%d" format specifier, but you're not actually giving it an integer; you're giving it a double-precision floating-point value (8.0, as it happens). When you lie to NSLog, its behavior is undefined, and you get unexpected results like this.

Don't lie to NSLog. If you want to convert the result of 2.0*4.0 to an integer before printing, you need to do that explicitly:

NSLog(@"%d", (int)(2.0*4.0));

If, instead, you want to print the result of 2.0*4.0 as a double-precision floating-point number, you need to use a different format specifier:

NSLog(@"%g", 2.0*4.0);

More broadly, this is true of any function that takes a variable number of arguments and some format string to tell it how to interpret them. It's up to you to make sure that the data you pass it matches the corresponding format specifiers; implicit conversions will not happen for you.

Answer 3

The first parameter to NSLog is a format string, then the second (and subsequent) parameters can be any types. The compiler doesn't know what the types should be at compile time and so doesn't try to cast them to anything. At run time NSLog assumes the second (and subsequent) parameters are as specified in the format string. If there's a mismatch unexpected and generally unhappy things happen.

Summary; Make sure you pass variables of the right type in the second (and subsequent) parameter.

Answer 4

In examples 2, 3 and 4, the float is either being assigned to an int (which converts it) or compared with an int (which also converts it). In 1, however, you're passing the float as an argument to a function. The printf function allows all the arguments after the initial format string to be of any type, so this is valid. But since the compiler doesn't know you mean for it to be an int (remember, you haven't done anything to let the compiler know), the float is passed along as a floating-point value. When printf sees the %d formatting specifier, it pops enough bytes for an int from the argument list and interprets those bytes as an int. Those bytes happen to look like an integer 0.

Answer 5

First, you never used floats in your program. They are doubles.

Second, the arguments of NSLog, printf and the likes are not automatically converted to what you specify using %d or %f. It follows the standard promotion rule for untyped arguments. See the ISO specification, sec 6.5.2.2.6 and 6.5.2.2.7. Note the super weird rule that inside these functions,

• a float is automatically promoted to double,
• and any integer smaller than an int is promoted to int. (see 6.3.1.1.2)

So, strictly speaking, the specification %f is not showing a float, but a double. See the same document, Sec. 7.19.6.1.8.

Note also that in your case 1 and 3, promotions are to double.