Sizeof с разными спецификаторами

sizeof оценивается как значение типа size_t. Правильным спецификатором для size_t в C99 является %zu. Вы можете использовать %u в системах, где size_t и unsigned int относятся к одному типу или, по крайней мере, имеют одинаковый размер и представление. В 64-битных системах значения size_t имеют 64 бита и, следовательно, больше, чем 32-битные целые числа. В 64-разрядных версиях Linux и OS/X этот тип определяется как unsigned long, а в 64-разрядных версиях Windows — как unsigned long long, поэтому использование %lu или %llu в этих системах также допустимо.

Передача size_t для несовместимой спецификации преобразования имеет неопределенное поведение:

• программа может рухнуть (и, вероятно, так и будет, если вы используете %s)
• программа может отображать ожидаемое значение (как это может быть для %d)
• программа может выдавать странный вывод, например, nan вместо %f или что-то еще...

Причина этого в том, что целые числа и значения с плавающей запятой по-разному передаются в printf, и они имеют другое представление. Передача целого числа, где printf ожидает double, позволит printf получить значение с плавающей запятой из регистров или областей памяти, которые имеют случайное содержимое. В вашем случае регистр с плавающей запятой просто содержит значение nan, но он может содержать другое значение в другом месте программы или позже, ничего нельзя ожидать, поведение не определено.

Некоторые устаревшие системы не поддерживают %zu, особенно среды выполнения C от Microsoft. В этих системах вы можете использовать %u или %lu и использовать приведение для преобразования size_t в unsigned или unsigned long:

int a = 0;
long long d = 1000000000000;
int s = a + d;
printf("%u\n", (unsigned)sizeof(a + d));       // should print 8
printf("%lu\n", (unsigned long)sizeof(s));     // should print 4
printf("%llu\n", (unsigned long long)sizeof(d)); // prints 4 or 8 depending on the system

Я хочу знать для себя, что происходит позади и почему он печатает nan, когда я использую его с %f, или длинное число, когда я использую его с %lf.

Некоторые причины.

Во-первых, printf не знает типы дополнительных аргументов, которые вы ему фактически передаете. Он полагается на строку формата, чтобы сообщить ему количество и типы дополнительных аргументов, которые нужно ожидать. Если вы передадите size_t в качестве дополнительного аргумента, но скажете printf ожидать float, то printf будет интерпретировать битовую комбинацию дополнительного аргумента как float, а не size_t. Целочисленные типы и типы с плавающей запятой имеют совершенно разные представления, поэтому вы получите значения, которых не ожидаете (включая NaN).

Во-вторых, разные типы имеют разные размеры. Если вы передадите 16-битное short в качестве аргумента, но скажете printf ожидать 64-битного double с %f, то printf будет искать дополнительные байты сразу после этого аргумента. Не гарантируется, что size_t и double имеют одинаковые размеры, поэтому printf может либо игнорировать часть фактического значения, либо использовать байты из памяти, которые не являются частью значения.

Наконец, это зависит от того, как передаются аргументы. В некоторых архитектурах для передачи аргументов (по крайней мере, для первых нескольких аргументов) используются регистры, а не стек, и разные регистры используются для чисел с плавающей запятой и целых чисел, поэтому, если вы передаете целое число и сообщаете ему ожидать двойное значение с %f, printf может посмотрите не в том месте и напечатайте что-то совершенно случайное.

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