Почему printf («% f», 0); дать неопределенное поведение?

Заявление

printf("%f\n",0.0f);

печатает 0.

Однако заявление

printf("%f\n",0);

печатает случайные значения.

Я понимаю, что проявляю какое-то неопределенное поведение, но не могу понять почему.

Значение с плавающей запятой, в котором все биты равны 0, по-прежнему допустимо floatсо значением 0.
floatИ intимеет тот же размер на моей машине (если это вообще актуально).

Почему использование целочисленного литерала вместо литерала с плавающей запятой printfвызывает такое поведение?

PS такое же поведение можно увидеть, если я использую

int i = 0;
printf("%f\n", i);

"%f"Формат требует аргумент типа double. Вы даете ему типовой аргумент int. Вот почему поведение не определено.

Стандарт не гарантирует, что все биты-ноль являются допустимым представлением 0.0(хотя это часто бывает) или любого doubleзначения, или что intи doubleимеют одинаковый размер (помните, что это doubleне так float), или даже если они одинаковы size, что они передаются в качестве аргументов функции с переменным числом аргументов таким же образом.

Это могло случиться с вашей системой. Это наихудший из возможных симптомов неопределенного поведения, поскольку он затрудняет диагностику ошибки.

N1570 7.21.6.1 пункт 9:

... Если какой-либо аргумент не является правильным типом для соответствующей спецификации преобразования, поведение не определено.

Аргументы типа floatповышаются до double, поэтому printf("%f\n",0.0f)работает. Аргументы целочисленных типов уже, чем intпродвигаются до intили до unsigned int. Эти правила продвижения (указанные в N1570 6.5.2.2 п.6) не помогают в случае printf("%f\n", 0).

Обратите внимание, что если вы передаете константу 0невариадной функции, которая ожидает doubleаргумент, поведение хорошо определено, при условии, что прототип функции виден. Например, sqrt(0)(после #include <math.h>) неявно преобразует аргумент 0из intв double- потому что компилятор может видеть из объявления, sqrtчто он ожидает doubleаргумент. Нет такой информации для printf. Такие функции с переменными числами, как printfособенные, требуют большей осторожности при написании их вызовов.

Во-первых, как было сказано в нескольких других ответах, но, на мой взгляд, недостаточно четко сказано: он действительно работает, чтобы предоставить целое число в большинстве контекстов, где библиотечная функция принимает аргумент doubleили float. Компилятор автоматически вставит преобразование. Например, sqrt(0)он четко определен и будет вести себя точно так же sqrt((double)0), и то же самое верно для любого другого выражения целого типа, используемого в нем.

printfотличается. Он отличается, потому что требует переменного количества аргументов. Его функциональным прототипом является

extern int printf(const char *fmt, ...);

Поэтому, когда вы пишете

printf(message, 0);

компилятор не имеет информации о том, какой тип printf ожидает от второго аргумента. У него есть только тип выражения аргумента, которым intнужно следовать. Поэтому, в отличие от большинства библиотечных функций, вы, программист, должны убедиться, что список аргументов соответствует ожиданиям строки формата.

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

Другая половина вопроса заключалась в следующем: учитывая, что (int) 0 и (float) 0.0 в большинстве современных систем представлены как 32 бита, все из которых равны нулю, почему это все равно не работает случайно? Стандарт C просто говорит: «Это не обязательно для работы, вы сами по себе», но позвольте мне указать две наиболее распространенные причины, по которым это не сработает; это, вероятно, поможет вам понять, почему это не требуется.

Во-первых, по историческим причинам, когда вы передаете a floatчерез список переменных аргументов, он продвигается к нему double, который в большинстве современных систем имеет ширину 64 бита. Таким образом, printf("%f", 0)вызываемому, ожидающему 64 из них, передается только 32 нулевых бита.

Вторая, не менее важная причина состоит в том, что аргументы функции с плавающей запятой могут передаваться в другом месте, чем целочисленные аргументы. Например, большинство процессоров имеют отдельные файлы регистров для целых чисел и значений с плавающей запятой, поэтому может быть правилом, что аргументы от 0 до 4 идут в регистры с r0 по r4, если они целые числа, но с f0 по f4, если они с плавающей запятой. Итак, printf("%f", 0)ищем этот ноль в регистре f1, но его там совсем нет.

Обычно, когда вы вызываете функцию, которая ожидает double, но вы предоставляете int, компилятор автоматически преобразует ее в double. Этого не происходит printf, потому что типы аргументов не указаны в прототипе функции - компилятор не знает, что нужно применить преобразование.

Почему использование целочисленного литерала вместо литерала с плавающей запятой вызывает такое поведение?

Потому printf()что не имеет типизированных параметров, кроме const char* formatstringкак 1-й. ...Для всего остального он использует многоточие в стиле c ( ).

Он просто решает, как интерпретировать переданные значения в соответствии с типами форматирования, указанными в строке формата.

У вас будет такое же неопределенное поведение, как при попытке

 int i = 0;
 const double* pf = (const double*)(&i);
 printf("%f\n",*pf); // dereferencing the pointer is UB

Использование несовпадающего printf()спецификатора "%f"и типа (int) 0приводит к неопределенному поведению.

Если спецификация преобразования недействительна, поведение не определено. C11dr §7.21.6.1 9

Возможные причины УБ.

1. Это UB по спецификации, а компиляция злобная, - сказал Нуф.

2. doubleи intбывают разных размеров.

3. doubleи intмогут передавать свои значения, используя разные стеки (общий или стек FPU ).

4. A не double 0.0 может быть определен полностью нулевым битовым шаблоном. (редко)

Это одна из тех прекрасных возможностей узнать о предупреждениях вашего компилятора.

$ gcc -Wall -Wextra -pedantic fnord.c 
fnord.c: In function ‘main’:
fnord.c:8:2: warning: format ‘%f’ expects argument of type ‘double’, but argument 2 has type ‘int’ [-Wformat=]
  printf("%f\n",0);
  ^

или

$ clang -Weverything -pedantic fnord.c 
fnord.c:8:16: warning: format specifies type 'double' but the argument has type 'int' [-Wformat]
        printf("%f\n",0);
                ~~    ^
                %d
1 warning generated.

Таким образом, printfвозникает неопределенное поведение, потому что вы передаете ему несовместимый тип аргумента.

Я не уверен, что сбивает с толку.

Ваша строка формата ожидает double; вместо этого вы предоставляете int.

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

"%f\n"гарантирует предсказуемый результат только тогда, когда второй printf()параметр имеет тип double. Затем дополнительные аргументы вариативных функций подвергаются продвижению аргументов по умолчанию. Целочисленные аргументы подпадают под целочисленное продвижение, которое никогда не приводит к значениям с плавающей запятой. И floatпараметры повышаются до double.

В довершение всего: стандарт позволяет второму аргументу быть или floatили doubleи ничем другим.

Почему это формально UB, теперь обсуждается в нескольких ответах.

Причина, по которой вы получаете именно такое поведение, зависит от платформы, но, вероятно, следующая:

• printfожидает своих аргументов в соответствии со стандартным распространением vararg. Это означает, что a floatбудет a, doubleа все, что меньше an, intбудет int.
• Вы передаете, intгде функция ожидает double. У вас int, вероятно, 32 бит, ваш double64 бит. Это означает, что четыре байта стека, начинающиеся с того места, где должен располагаться аргумент, есть 0, но следующие четыре байта имеют произвольное содержимое. Это то, что используется для построения отображаемого значения.

Основная причина этой проблемы с "неопределенным значением" заключается в приведении указателя к intзначению, переданному в printfраздел переменных параметров, к указателю на doubleтипы, которые va_argвыполняет макрос.

Это вызывает ссылку на область памяти, которая не была полностью инициализирована значением, переданным в качестве параметра printf, потому что doubleразмер буферной области памяти больше intразмера.

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


Он может учитывать эти конкретные части реализации полупрофессионального кода «printf» и «va_arg» ...

printf

va_list arg;
....
case('%f')
      va_arg ( arg, double ); //va_arg is a macro, and so you can pass it the "type" that will be used for casting the int pointer argument of printf..
.... 

Реальная реализация в vprintf (с учетом gnu impl.) управления случаем кода параметров с двойным значением:

if (__ldbl_is_dbl)
{
   args_value[cnt].pa_double = va_arg (ap_save, double);
   ...
}

va_arg

char *p = (double *) &arg + sizeof arg;  //printf parameters area pointer

double i2 = *((double *)p); //casting to double because va_arg(arg, double)
   p += sizeof (double);

Ссылки

1. gnu project glibc реализация printf (vprintf))
2. пример кода расширения printf
3. пример кода расширения va_arg