Cross platform format string for variables of type size_t?

Question

On a cross platform c/c++ project (Win32, Linux, OSX), I need to use the *printf functions to print some variables of type size_t. In some environments size_t's are 8 bytes and on others they are 4. On glibc I have %zd, and on Win32 I can use %Id. Is there an elegant way to handle this?

Answer 1

The PRIuPTR macro (from <inttypes.h>) defines a decimal format for uintptr_t, which should always be large enough that you can cast a size_t to it without truncating, e.g.

fprintf(stream, "Your size_t var has value %" PRIuPTR ".", (uintptr_t) your_var);

Answer 2

There are really two questions here. The first question is what the correct printf specifier string for the three platforms is. Note that size_t is an unsigned type.

On Windows, use "%Iu".

On Linux and OSX, use "%zu".

The second question is how to support multiple platforms, given that things like format strings might be different on each platform. As other people have pointed out, using #ifdef gets ugly quickly.

Instead, write a separate makefile or project file for each target platform. Then refer to the specifier by some macro name in your source files, defining the macro appropriately in each makefile. In particular, both GCC and Visual Studio accept a 'D' switch to define macros on the command line.

If your build system is very complicated (multiple build options, generated sources, etc.), maintaining 3 separate makefiles might get unwieldly, and you are going to have to use some kind of advanced build system like CMake or the GNU autotools. But the basic principle is the same-- use the build system to define platform-specific macros instead of putting platform-detection logic in your source files.

Answer 3

The only thing I can think of, is the typical:

#ifdef __WIN32__ // or whatever
#define SSIZET_FMT "%ld"
#else
#define SSIZET_FMT "%zd"
#endif

and then taking advantage of constant folding:

fprintf(stream, "Your size_t var has value " SSIZET_FMT ".", your_var);

Answer 4

Dan Saks wrote an article in Embedded Systems Design which covered this matter. According to Dan, %zu is the standard way, but few compilers supported this. As an alternative, he recommended using %lu together with an explicit cast of the argument to unsigned long:

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

Answer 5

Use boost::format. It's typesafe, so it'll print size_t correctly with %d, also you don't need to remember to put c_str() on std::strings when using it, and even if you pass a number to %s or vice versa, it'll work.

Answer 6

You just have to find an integer type with the largest storage class, cast the value to it, and then use the appropriate format string for the larger type. Note this solution will work for any type (ptrdiff_t, etc.), not just size_t.

What you want to use is uintmax_t and the format macro PRIuMAX. For Visual C++, you are going to need to download c99-compatible stdint.h and inttypes.h headers, because Microsoft doesn't provide them.

Also see

http://www.embedded.com/columns/technicalinsights/204700432

This article corrects the mistakes in the article quoted by Frederico.

Answer 7

I don't know of any satisfying solution, but you might consider a specialized function to format size_t items to a string, and print the string.

(Alternatively, if you can get away with it, boost::format handles this kind of thing with ease.)

Answer 8

My choice for that problem is to simply cast the size_t argument to unsigned long and use %lu everywhere - this of course only where values are not expected to exceed 2^32-1. If this is too short for you, you could always cast to unsigned long long and format it as %llu.

Either way, your strings will never be awkward.

Answer 9

Option 1:

Since on most (if not all?) systems, the PRIuPTR printf format string from is also long enough to hold a size_t type, I recommend using the following defines for size_t printf format strings.

However, it is important that you verify this will work for your particular architecture (compiler, hardware, etc), as the standard does not enforce this.

#include <inttypes.h>

// Printf format strings for `size_t` variable types.
#define PRIdSZT PRIdPTR
#define PRIiSZT PRIiPTR
#define PRIoSZT PRIoPTR
#define PRIuSZT PRIuPTR
#define PRIxSZT PRIxPTR
#define PRIXSZT PRIXPTR

Example usage:

size_t my_variable;
printf("%" PRIuSZT "\n", my_variable);

Option 2:

Where possible, however, just use the %zu "z" length specifier, as shown here, for size_t types:

Example usage:

size_t my_variable;
printf("%zu\n", my_variable);

On some systems, however, such as STM32 microcontrollers using gcc as the compiler, the %z length specifier isn't necessarily implemented, and doing something like printf("%zu\n", my_size_t_num); may simply end up printing out a literal "%zu" (I personally tested this and found it to be true) instead of the value of your size_t variable.

Option 3:

Where you need it to be absolutely guaranteed to work, however, or where you aren't sure about your particular architecture, just cast and print as a uint64_t and be done, as this is guaranteed to work, but requires the extra step of casting.

Example usage:

#include <stdint.h>    // for uint64_t
#include <inttypes.h>  // for PRIu64

size_t my_variable;
printf("%" PRIu64 "\n", (uint64_t)my_variable);

Sources Cited:

1. http://www.cplusplus.com/reference/cstdio/printf/
2. http://www.cplusplus.com/reference/cinttypes/
3. http://www.cplusplus.com/reference/cstdint/

Answer 10

size_t is an unsigned type of at least 16 bits. Widths of 32 and 64 are often seen.

printf("%zu\n", some_size_t_object); // Standard since C99

Above is the best way going forward, yet if code needs to also port to pre-C99 platforms, covert the value to some wide type. unsigned long is reasonable candidate yet may be lacking.

// OK, yet insufficient with large sizes > ULONG_MAX
printf("%lu\n", (unsigned long) some_size_t_object); 

or with conditional code

#ifdef ULLONG_MAX
  printf("%llu\n", (unsigned long long) some_size_t_object); 
#else
  printf("%lu\n", (unsigned long) some_size_t_object); 
#endif

Lastly consider double. It is a bit inefficient yet should handle all ancient and new platforms until about the years 2030-2040 considering Moore's law when double may lack a precise result.

printf("%.0f\n", (double) some_size_t_object);