Как можно напечатать переменную size_t с помощью семейства printf?

У меня есть переменная типа size_t, и я хочу напечатать ее с помощью printf(). Какой спецификатор формата я использую для его печати?

В 32-битной машине, %uпохоже, прав. Я собрал g++ -g -W -Wall -Werror -ansi -pedantic, и не было никакого предупреждения. Но когда я компилирую этот код на 64-битной машине, он выдает предупреждение.

size_t x = <something>;
printf("size = %u\n", x);

warning: format '%u' expects type 'unsigned int', 
    but argument 2 has type 'long unsigned int'

Как и ожидалось, предупреждение исчезнет, ​​если я поменяю его на %lu.

Вопрос в том, как мне написать код, чтобы он свободно компилировал предупреждения на 32- и 64-разрядных компьютерах?

Изменить: В качестве обходного пути, я думаю, один из ответов может быть «привести» переменную в целое число, например unsigned long, достаточно большой, и распечатать с помощью %lu. Это будет работать в обоих случаях. Я смотрю, есть ли другая идея.

Используйте zмодификатор:

size_t x = ...;
ssize_t y = ...;
printf("%zu\n", x);  // prints as unsigned decimal
printf("%zx\n", x);  // prints as hex
printf("%zd\n", y);  // prints as signed decimal

Похоже, это зависит от того, какой компилятор вы используете (blech):

• GNU говорит%zu (или %zx, или, %zdно это показывает, как будто оно было подписано, и т. д.)
• Microsoft говорит%Iu (или %Ix, или, %Idно опять же, подписано и т. Д.) - но по состоянию на cl v19 (в Visual Studio 2015) Microsoft поддерживает %zu (см. Этот ответ на этот комментарий )

... и, конечно, если вы используете C ++, вы можете использовать coutвместо этого, как предложено AraK .

Для C89 используйте %luи приведите значение к unsigned long:

size_t foo;
...
printf("foo = %lu\n", (unsigned long) foo);

Для C99 и более поздних версий используйте %zu:

size_t foo;
...
printf("foo = %zu\n", foo);

Расширение на ответ Адама Розенфилда для Windows.

Я тестировал этот код на VS2013 Update 4 и VS2015 preview:

// test.c

#include <stdio.h>
#include <BaseTsd.h> // see the note below

int main()
{
    size_t x = 1;
    SSIZE_T y = 2;
    printf("%zu\n", x);  // prints as unsigned decimal
    printf("%zx\n", x);  // prints as hex
    printf("%zd\n", y);  // prints as signed decimal
    return 0;
}

VS2015 генерирует двоичные выходы:

1
1
2

в то время как тот, созданный VS2013, говорит:

ZU
ZX
ZD

Примечание: ssize_tэто расширение POSIX и SSIZE_Tаналогичное в типах данных Windows , поэтому я добавил <BaseTsd.h>ссылку.

Кроме того, за исключением следующих заголовков C99 / C11, все заголовки C99 доступны в предварительном просмотре VS2015:

C11 - <stdalign.h>
C11 - <stdatomic.h>
C11 - <stdnoreturn.h>
C99 - <tgmath.h>
C11 - <threads.h>

Кроме того, C11 <uchar.h>теперь включен в последний предварительный просмотр.

Для получения дополнительной информации см. Этот старый и новый список для соответствия стандарту.

Тем, кто говорит об этом в C ++, который не обязательно поддерживает расширения C99, я настоятельно рекомендую boost :: format. Это делает вопрос размера size_t спорным:

std::cout << boost::format("Sizeof(Var) is %d\n") % sizeof(Var);

Поскольку вам не нужны указатели размера в boost :: format, вы можете просто беспокоиться о том, как вы хотите отобразить значение.

std::size_t s = 1024;
std::cout << s; // or any other kind of stream like stringstream!

printf("size = %zu\n", sizeof(thing) );

Как сказал АраК, интерфейс потоков c ++ всегда будет работать переносимо.

std :: size_t s = 1024; std :: cout << s; // или любой другой вид потока, например, stringstream!

Если вы хотите использовать C stdio, для некоторых случаев «портативного» ответа на этот вопрос не существует. И это уродливо, поскольку, как вы уже видели, выбор неправильных флагов формата может привести к предупреждению компилятора или неверному выводу.

C99 пытался решить эту проблему с помощью таких форматов inttypes.h, как "%" PRIdMAX "\ n". Но, как и в случае с «% zu», не все поддерживают c99 (как MSVS до 2013 года). Есть файлы "msinttypes.h", которые разбираются с этим.

Если вы приведете к другому типу, в зависимости от флагов вы можете получить предупреждение компилятора об усечении или изменении знака. Если вы идете по этому маршруту, выберите больший соответствующий тип фиксированного размера. Один из unsigned long long и "% llu" или unsigned long "% lu" должен работать, но llu также может замедлить работу в 32-битном мире как чрезмерно большой. (Изменить - мой Mac выдает предупреждение в 64-битной версии, что% llu не соответствует size_t, хотя% lu,% llu и size_t имеют одинаковый размер. И% lu и% llu не совпадают по размеру на моем MSVS2012. вам может понадобиться привести + использовать формат, который соответствует.)

В этом отношении вы можете использовать фиксированные размеры, такие как int64_t. Но ждать! Теперь мы вернулись к c99 / c ++ 11, и старый MSVS снова дает сбой. Плюс у вас также есть приведения (например, map.size () не является фиксированным размером)!

Вы можете использовать сторонний заголовок или библиотеку, такую ​​как boost. Если вы еще не используете его, возможно, вы не захотите раздувать свой проект таким образом. Если вы готовы добавить один только для этой проблемы, почему бы не использовать потоки C ++ или условную компиляцию?

Таким образом, вы знакомы с потоками c ++, условной компиляцией, сторонними фреймворками или чем-то вроде портативного устройства, которое работает на вас.

Будет ли он предупреждать вас, если вы передадите 32-разрядное целое число без знака в формат% lu? Это должно быть хорошо, так как преобразование четко определено и не теряет никакой информации.

Я слышал, что некоторые платформы определяют макросы в <inttypes.h>том смысле, что вы можете вставить их в строковый литерал формата, но я не вижу этого заголовка в моем компиляторе Windows C ++, что подразумевает, что он не может быть кроссплатформенным.

C99 определяет "% zd" и т. Д. Для этого. (спасибо комментаторам) В C ++ нет переносимого спецификатора формата - вы можете использовать %p, какое слово woulkd в этих двух сценариях, но также не является переносимым выбором, и дает значение в шестнадцатеричном формате.

В качестве альтернативы используйте потоковую передачу (например, stringstream) или безопасную замену printf, например Boost Format . Я понимаю, что этот совет имеет ограниченное использование (и требует C ++). (Мы использовали подобный подход, приспособленный для наших нужд при реализации поддержки юникода.)

Фундаментальная проблема для C состоит в том, что printf, использующий многоточие, небезопасен по своей конструкции - он должен определить размер дополнительного аргумента из известных аргументов, поэтому он не может быть исправлен для поддержки «что бы вы ни получили». Так что, если ваш компилятор не реализует некоторые проприетарные расширения, вам не повезло.

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

Я задокументировал эту сложную проблему здесь, с примером кода: http://www.pixelbeat.org/programming/gcc/int_types/ и периодически обновляю его информацией о новых платформах и типах.

если вы хотите напечатать значение size_t в виде строки, вы можете сделать это:

char text[] = "Lets go fishing in stead of sitting on our but !!";
size_t line = 2337200120702199116;

/* on windows I64x or I64d others %lld or %llx if it works %zd or %zx */
printf("number: %I64d\n",*(size_t*)&text);
printf("text: %s\n",*(char(*)[])&line);

результат:

номер: 2337200120702199116

Текст: Пойдем на рыбалку вместо того, чтобы сидеть на нашем но !!

Редактировать: перечитывая вопрос из-за отрицательных голосов, я заметил, что его проблема не в% llu или% I64d, а в типе size_t на разных машинах, смотрите этот вопрос https://stackoverflow.com/a/918909/1755797
http: // www. cplusplus.com/reference/cstdio/printf/

size_t - это unsigned int на 32-битной машине и unsigned long long int на 64-битной системе,
но% ll всегда ожидает unsigned long long int.

size_t различается по длине в разных операционных системах, в то время как% llu одинаково