How many chars do I need to print a size_t with sprintf?

Question

I want to do something like this:

char sLength[SIZE_T_LEN];

sprintf(sLength, "%zu", strlen(sSomeString));

That is, I want to print in a buffer a value of type size_t. The question is: what should be the value of SIZE_T_LEN? The point is to know the minimum size required in order to be sure that an overflow will never occur.

Answer 1

sizeof(size_t) * CHAR_BIT (from limits.h) gives the number of bits. For decimal output, use a (rough) lower estimate of 3 (4 for hex) bits per digit to be on the safe side. Don't forget to add 1 for the nul terminator of a string.

So:

#include <limits.h>

#define SIZE_T_LEN ( (sizeof(size_t) * CHAR_BIT + 2) / 3 + 1 )

This yields a value of type size_t itself. On typical 8/16/32/64 bit platforms + 2 is not required (the minimum possible size of size_t is 16 bits). Here the error is already large enough to yield a correctly truncated result.

Note that this gives an upper bound and is fully portable due to the use of CHAR_BIT. To get an exact value, you have to use log10(SIZE_MAX) (see JohnBollinger's answer for this). But that yields a float and might be calculated at run-time, while the version above is compile-time evaluated (and likely costs more stack than the rough estimate already). Unless you have a very RAM constrained system, that is ok. And on such a system, you should refrain from using stdio anyway.

To be absolutely on the safe side, you might want to use snprintf (but that is not necessary).

Answer 2

The exact answer, accounting for space for a string terminator, would be

 log10(SIZE_MAX) + 2

where the SIZE_MAX macro is declared in stdint.h. Unfortunately, that's not a compile-time constant (on account of the use of log10()). If you need a compile-time constant that is computed at compile time then you could use this:

sizeof(size_t) * CHAR_BIT * 3 / 10 + 2

That gives the correct answer for size_t up to at least 256 bits. It's based on the fact that 2¹⁰ is pretty close to 1000. At some large number of bits it will be too small by one, and for much larger numbers of bits it will fall further behind. If you're worried about such large size_t then you could add one or even two to the result.

Answer 3

If you can use snprintf, use:

int len = snprintf (NULL, 0, "%zu", strlen (sSomeString));

Answer 4

On systems where a char is represented using 8 bits,

If sizeof(size_t) is 2, then, the maximum value is: 65535
If sizeof(size_t) is 4, then, the maximum value is: 4294967295
If sizeof(size_t) is 8, then, the maximum value is: 18446744073709551615
If sizeof(size_t) is 16, then, the maximum value is: 3.4028237e+38

You can use that information to extract maximum size of the string using the pre-processor.

Sample program:

#include <stdio.h>

#ifdef MAX_STRING_SIZE
#undef MAX_STRING_SIZE
#endif

// MAX_STRING_SIZE is 6 when sizeof(size_t) is 2
// MAX_STRING_SIZE is 11 when sizeof(size_t) is 4
// MAX_STRING_SIZE is 21 when sizeof(size_t) is 8
// MAX_STRING_SIZE is 40 when sizeof(size_t) is 16
// MAX_STRING_SIZE is -1 for all else. It will be an error to use it 
// as the size of an array.

#define MAX_STRING_SIZE (sizeof(size_t) == 2 ? 6 : sizeof(size_t) == 4 ? 11 : sizeof(size_t) == 8 ? 21 : sizeof(size_t) == 16 ? 40 : -1)

int main()
{
   char str[MAX_STRING_SIZE];
   size_t a = 0xFFFFFFFF;

   sprintf(str, "%zu", a);
   printf("%s\n", str);

   a = 0xFFFFFFFFFFFFFFFF;
   sprintf(str, "%zu", a);
   printf("%s\n", str);
}

Output:

4294967295
18446744073709551615

It will be easy to adapt it to systems where a char is represented using 16 bits.