Использование %f для печати целочисленной переменной

Из последнего проекта C11:

§7.16.1.1/2

...if type is not compatible with the type of the actual next argument 
(as promoted according to the default argument promotions), the behavior 
is undefined, except for the following cases:

— one type is a signed integer type, the other type is the corresponding 
unsigned integer type, and the value is representable in both types;
— one type is pointer to void and the other is a pointer to a character type.

Самое главное помнить, что, как указывает Крис, поведение не определено. Если бы это было в реальной программе, единственное, что можно было бы сделать, это исправить код.

С другой стороны, наблюдение за поведением кода, поведение которого не определено стандартом языка, может быть поучительным (при условии, что вы не слишком обобщаете поведение).

Формат printf "%f" ожидает аргумент типа double и печатает его в десятичной форме без экспоненты. Очень маленькие значения будут напечатаны как 0.000000.

Когда вы делаете это:

int x=10;
printf("%f", x);

мы можем объяснить видимое поведение, учитывая несколько предположений о платформе, на которой вы находитесь:

• int составляет 4 байта
• double составляет 8 байт
• Аргументы int и double передаются в printf с использованием одного и того же механизма, вероятно, в стеке.

Таким образом, вызов (правдоподобно) поместит int значение 10 в стек как 4-байтовое количество, а printf возьмет 8 байтов данных из стека и обработает их как представление double. 4 байта будут представлением 10 (в шестнадцатеричном формате, 0x0000000a); остальные 4 байта будут мусором, скорее всего нулевым. Мусором могут быть как старшие, так и младшие 4 байта из 8-байтового количества. (Или что-нибудь еще; помните, что поведение не определено.)

Вот демонстрационная программа, которую я только что собрал. Вместо того, чтобы злоупотреблять printf, он копирует представление объекта int в объект double, используя memcpy().

#include <stdio.h>
#include <string.h>

void print_hex(char *name, void *addr, size_t size) {
    unsigned char *buf = addr;
    printf("%s = ", name);
    for (int i = 0; i < size; i ++) {
        printf("%02x", buf[i]);
    }
    putchar('\n');
}

int main(void) {
    int i = 10;
    double x = 0.0;
    print_hex("i (set to 10)", &i, sizeof i);
    print_hex("x (set to 0.0)", &x, sizeof x);

    memcpy(&x, &i, sizeof (int));
    print_hex("x (copied from i)", &x, sizeof x);
    printf("x (%%f format) = %f\n", x);
    printf("x (%%g format) = %g\n", x);

    return 0;
}

Вывод в моей системе x86:

i (set to 10) = 0a000000
x (set to 0.0) = 0000000000000000
x (copied from i) = 0a00000000000000
x (%f format) = 0.000000
x (%g format) = 4.94066e-323

Как видите, значение double очень мало (подробности можно найти в справочнике по формату с плавающей запятой IEEE), достаточно близко к нулю, чтобы "%f" печатало его как 0.000000.

Подчеркну еще раз, что поведение не определено, что конкретно означает, что стандарт языка «не налагает никаких требований» на поведение программы. Изменения в порядке байтов, в представлении с плавающей запятой и в соглашениях о передаче аргументов могут существенно изменить результаты. На это может повлиять даже оптимизация компилятора; компиляторам разрешено предполагать, что поведение программы хорошо определено, и выполнять преобразования на основе этого предположения.

Поэтому пожалуйста не стесняйтесь игнорировать все, что я здесь написал (кроме первого и последнего абзацев).

Потому что целое число 10 в двоичном виде выглядит так:

00000000 00000000 00000000 00001010

Все, что делает printf, это берет представление в памяти и пытается представить его как число с плавающей запятой IEEE 754.

Число с плавающей запятой состоит из трех частей (от MSB до LSB):

Знак: 1 бит
Показатель степени: 8 бит
Мантисса: 23 бита

Поскольку целое число 10 равно 1010 в битах мантиссы, это очень крошечное число, которое намного меньше, чем точность по умолчанию для формата с плавающей запятой printf.

Результат не определен.

Я просто спрашиваю это с теоретической точки зрения.

Полный крис отличный ответ :

int main()
{
    int i       = 10 ;
    void * pi   = &i ;
    double * pf = (double *) pi ; /* oranges are apples ! */
    double f    = *pf ;

    /* what is the value inside f ? */

    return 0;
}

typedef union
{
   char c[8] ; /* char is expected to be 1-byte wide     */
   double f ;  /* double is expected to be 8-bytes wide  */
   int i ;     /* int is expected to be 4-byte wide      */
} MyUnion ;

void printMyUnion(MyUnion * p)
{
   printf("[%i %i %i %i %i %i %i %i]\n"
      , p->c[0], p->c[1], p->c[2], p->c[3], p->c[4], p->c[5], p->c[6], p->c[7]) ;
}

int main()
{
   /* this will zero all the fields in the union */
   memset(myUnion.c, 0, 8 * sizeof(char)) ;
   printMyUnion(&myUnion) ; /* this should print only zeroes */
                            /* eg. [0 0 0 0 0 0 0 0] */

   memset(myUnion.c, 0, 8 * sizeof(char)) ;
   myUnion.i = 10 ;
   printMyUnion(&myUnion) ; /* the representation of the int 10 in the union */
                            /* eg. [10 0 0 0 0 0 0 0] */

   memset(myUnion.c, 0, 8 * sizeof(char)) ;
   myUnion.f = 10 ;
   printMyUnion(&myUnion) ; /* the representation of the double 10 in the union */
                            /* eg. [0 0 0 0 0 0 36 64] */

   memset(myUnion.c, 0, 8 * sizeof(char)) ;
   myUnion.f = 3.1415 ;
   printMyUnion(&myUnion) ; /* the representation of the double 3.1415 in the union */
                            /* eg. [111 18 -125 -64 -54 33 9 64] */

   return 0 ;
}

int main()
{
   int x=10;
   printf("%f",(double)(x));
   return 0;
}

   /* printf("...", [[10 0 0 0]]) ; */
   printf("%i",x);

   /* printf("...", [[10 0 0 0 ?? ?? ?? ??]]) ; */
   printf("%f",x);

   /* printf("...", [[0 0 0 0 0 0 36 64]]) ; */
   printf("%f",(double)(x));