How to print size_t variable portably?

Question

I have a variable of type size_t, and I want to print it using printf(). What format specifier do I use to print it portably?

In 32-bit machine, %u seems right. I compiled with g++ -g -W -Wall -Werror -ansi -pedantic, and there was no warning. But when I compile that code in 64-bit machine, it produces warning.

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

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

The warning goes away, as expected, if I change that to %lu.

The question is, how can I write the code, so that it compiles warning free on both 32- and 64- bit machines?

Edit: I guess one answer might be to "cast" the variable into an unsigned long, and print using %lu. That would work in both cases. I am looking if there is any other idea.

(C, C++)

Answer 1

I've compiled it warning-free on a 32-bit machine with %lu.

Answer 2

#ifndef _LP64
    printf( "size = %u\n", x );
#else
    printf( "size = %lu\n", x );
#endif

Nasty but it works :)

Answer 3

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

Answer 4

Will it warn you if you pass a 32-bit unsigned integer to a %lu format? It should be fine since the conversion is well-defined and doesn't lose any information.

I've heard that some platforms define macros in <inttypes.h> that you can insert into the format string literal but I don't see that header on my Windows C++ compiler, which implies it may not be cross-platform.

Answer 5

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

Answer 6

Looks like it varies depending on what compiler you're using (blech):

• gnu says %zd (or %zx, %zu, etc.)
• Microsoft says %Id (or %Ix, %Iu, etc.)

...and of course, if you're using C++, you can use cout instead as suggested by AraK.

Answer 7

Use the z modifier:

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

Answer 8

C99 defines "%zd" etc. for that. (thanks to the commenters) There is no portable format specifier for that in C++ - you could use %p, which woulkd word in these two scenarios, but isn't a portable choice either, and gives the value in hex.

Alternatively, use some streaming (e.g. stringstream) or a safe printf replacement such as Boost Format. I understand that this advice is only of limited use (and does require C++). (We've used a similar approach fitted for our needs when implementing unicode support.)

The fundamental problem for C is that printf using an ellipsis is unsafe by design - it needs to determine the additional argument's size from the known arguments, so it can't be fixed to support "whatever you got". So unless your compiler implement some proprietary extensions, you are out of luck.

Answer 9

For C89: use %lu and cast to unsigned long:

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

For C99, use %zu:

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

Answer 10

For those talking about doing this in C++ which doesn't necessarily support the C99 extensions, then I heartily recommend boost::format. This makes the size_t type size question moot:

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

Since you don't need size specifiers in boost::format, you can just worry about how you want to display the value.