Understanding implicit conversions for printf

Question

The C99 Standard differentiate between implicit and explicit type conversions (6.3 Conversions). I guess, but could not found, that implicit casts are performed, when the target type is of greater precision than the source, and can represent its value. [That is what I consider to happen from INT to DOUBLE]. Given that, I look at the following example:

#include <stdio.h>  // printf
#include <limits.h> // for INT_MIN
#include <stdint.h> // for endianess
#define IS_BIG_ENDIAN (*(uint16_t *)"\0\xff" < 0x100)

int main()
{
  printf("sizeof(int): %lu\n", sizeof(int));
  printf("sizeof(float): %lu\n", sizeof(float));
  printf("sizeof(double): %lu\n", sizeof(double));
  printf( IS_BIG_ENDIAN == 1 ? "Big" : "Little" ); printf( " Endian\n" );

  int a = INT_MIN;
  printf("INT_MIN: %i\n", a);
  printf("INT_MIN as double (or float?): %e\n", a);
}

I was very surprised to find that output:

sizeof(int): 4
sizeof(float): 4
sizeof(double): 8
Little Endian
INT_MIN: -2147483648
INT_MIN as double (or float?): 6.916919e-323

So the float value printed is a subnormal floating point number near the very minimal subnormal positive double 4.9406564584124654 × 10^−324. Strange things happen when I comment out the two printf for endianess, I get another value for the double:

#include <stdio.h>  // printf
#include <limits.h> // for INT_MIN
#include <stdint.h> // for endianess
#define IS_BIG_ENDIAN (*(uint16_t *)"\0\xff" < 0x100)

int main()
{
  printf("sizeof(int): %lu\n", sizeof(int));
  printf("sizeof(float): %lu\n", sizeof(float));
  printf("sizeof(double): %lu\n", sizeof(double));
  // printf( IS_BIG_ENDIAN == 1 ? "Big" : "Little" ); printf( " Endian\n" );

  int a = INT_MIN;
  printf("INT_MIN: %i\n", a);
  printf("INT_MIN as double (or float?): %e\n", a);
}

output:

sizeof(int): 4
sizeof(float): 4
sizeof(double): 8
INT_MIN: -2147483648
INT_MIN as double (or float?): 4.940656e-324

gcc --version: (Ubuntu 4.8.2-19ubuntu1) 4.8.2
uname: x86_64 GNU/Linux
compiler options where: gcc -o x x.c -Wall -Wextra -std=c99 --pedantic
And yes there where one warning:

x.c: In function ‘main’:
x.c:15:3: warning: format ‘%e’ expects argument of type ‘double’, but argument 2
          has type ‘int’ [-Wformat=]

   printf("INT_MIN as double (or float?): %e\n", a);
   ^

But I still cannot understand what exactly is happening.

in little endianess I consider MIN_INT as: 00...0001 and MIN_DBL (Subnormal) as 100..00#, starting with the mantissa, followed by the exponent and conclude with the # as sign bit.
Is this form of applying "%e" format specifier on an int, is a implicit cast?, a reinterpret cast?

I am lost, please enlight me.

There is a difference between `cast`-ing and supplying incompatible `format specifier`s for `printf()`. Later action leads to UB. — Sourav Ghosh, Nov 05 '14 at 07:07
I suggest you modify your code to have one correct printf and one incorrect printf, then compile to assembly and take a look at the difference between the two. You'll find out how a double is supposed to be passed in a varargs function, and how it tried to pass your int as the double. — JS1, Nov 05 '14 at 07:17

score 2 · Answer 1 · edited May 23 '17 at 12:13

2

printf("INT_MIN as double (or float?): %e\n", a);

Above line has problem You can not use %e to print ints. The behavior is undefined.

You should use

printf("INT_MIN as double (or float?): %e\n", (double)a);

or

double t = a;
printf("INT_MIN as double (or float?): %e\n", t);

Related post: This post explains how using incorrect print specifiers in printf can lead to UB.

edited May 23 '17 at 12:13

Community

1
1

answered Nov 05 '14 at 07:01

Mohit Jain

30,259
8
73
100

The related post was very helpful. – math Nov 05 '14 at 07:05

score 0 · Answer 2 · answered Nov 05 '14 at 10:13

Arguments to va_arg functions are not converted, syntactically the compiler knows nothing about the arguments for such functions, so he can't do that. Modern compilers do know to interpret the format string, though, and so they are able to warn you when something fishy is going on. That's what happening when you see the warning from gcc.

To be more precise, there are some promotions that are done for narrow integer types, they are promoted to int, and for float which is promoted to double. But that is all magic that can happen, here.

In summary, always use the correct format specifier.

BTW, for size_t as of your sizeof expressions the correct one is %zu.

Understanding implicit conversions for printf

2 Answers2

Linked