5

The following code works: 

int main(void)
{  
   float f = get_float();
   int i = round(f*100);
   printf("%i\n", i); 
}

Yet, error generated if coding this way:

printf("%i\n", round(1.21*100));

Output says round(1.21*100) is float. So, then why 

int i = round(f*100);

is fine?

Andre Kampling
  • 5,476
  • 2
  • 20
  • 47
juanli
  • 583
  • 2
  • 7
  • 19
  • 3
    When a `float` value is assigned to `int` values, an internal conversion takes place. `round()` gives an double value, so if no conversion is performed it's value remains double. In this specified case `printf("%i\n", round(1.21*100));` no conversion is performed, so it requires '%f' specifier to print float value. – svtag Jul 19 '17 at 08:54

3 Answers3

16

When you do

int i = round(f*100);

you convert the result of the double function round. The converted result is stored in the int variable i, which can be used with the format "%i" as it expects an int argument.

When you pass the double result of round directly as an argument to a format that expects an int you have mismatching format and argument types. That leads to undefined behavior.

No conversion is made in the call to printf, and no conversion can be made since the code inside the printf function doesn't know the actual type of the argument. All it knows is the format "%i". All possible type-information is lost for variable-argument functions.

Some programmer dude
  • 400,186
  • 35
  • 402
  • 621
5

This is because of the behavior of automatic type casting. In printf, automatic typecasting does not work. When you say %i, it simply expects integer, it can not convert double to integer and then print.

In assignment operation, double is converted to integer first and then it is assigned to left operand of the = operator. I hope this helps.

Darshan Prajapati
  • 843
  • 2
  • 11
  • 33
4

This is a bit of duplication, but maybe helps for a better understanding:

  1. round() has the following prototype:

    double round(double x);

    so it returns double.

  2. There is an implicit conversion from double to int in C, so writing

    int i = round(f*100);

    will convert the result of round() to int.

  3. If you have a function that expects an int, e.g.

    void printMyNumber(int number)
{
    printf("%i\n", number);
}

    you can call it like this:

    printMyNumber(round(f*100));

    and the implicit conversion works as expected, because the compiler sees both types (the return type from round() and the expected argument type of printMyNumber()).

  4. The reason this doesn't work with printf() is that the prototype of printf() looks like this:

    printf(const char *format, ...);

    so, except for the first argument, the types of the arguments are unknown. Therefore, whatever you pass is passed without any conversion (except for default argument promotions). Of course, you could use a cast to achieve an explicit conversion instead:

    printf("%i\n", (int) round(f*100)); // <- this is fine