ChatGPT解决这个技术问题 Extra ChatGPT

How can one print a size_t variable portably using the printf family?

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: As a workaround, I guess one answer might be to "cast" the variable into an integer that is big enough, say unsigned long, and print using %lu. That would work in both cases. I am looking if there is any other idea.

casting to unsigned long is the best option if your libc implementation doesn't support the z modifier; the C99 standard recommends size_t not to have an integer conversion rank greater than long, so you're reasonably safe
On the Windows platform size_t can be larger than long. For compatibility reasons long is always 32-bit but size_t can be 64-bit. So, casting to unsigned long may lose half of the bits. Sorry :-)

A
Adam Rosenfield

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

+1. Is this a C99 addition or does this apply to C++ as well (I don't have C90 handy)?
it's a C99 addition and not featured in the list of printf() length modifiers of the C++0x draft from 2009-11-09 (table 84 on page 672)
@Christoph: Nor is it in the latest draft, n3035.
@avakar @Adam Rosenfield @Christoph @GMan: However, in n3035 §1.2 Normative references, only the C99 standard is referenced, and §17.6.1.2/3 of the same states "The facilities of the C standard library are provided." I would interpret this to mean that, unless otherwise specified, everything in the C99 standard library is part of the C++0x standard library, including the additional format specifiers in C99.
@ArunSaha: It's a feature of only C99, not C++. If you want it to compile with -pedantic, you'll need to either get a compiler supporting the C++1x draft (highly unlikely), or you'll need to move your code into a file that's compiled as C99. Otherwise, your only option is to cast your variables to unsigned long long and use %llu to be maximally portable.
C
Community

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

gnu says %zu (or %zx, or %zd but that displays it as though it were signed, etc.)

Microsoft says %Iu (or %Ix, or %Id but again that's signed, etc.) — but as of cl v19 (in Visual Studio 2015), Microsoft supports %zu (see this reply to this comment)

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


z is also supported by newlib (ie cygwin)
%zd is incorrect for size_t; it's correct for the signed type corresponding to size_t, but size_t itself is an unsigned type.
@KeithThompson: I did mention %zu as well (and %zx in case they want hex). True enough that %zu should probably have been first in the list. Fixed.
@T.J.Crowder: I don't think %zd should be in the list at all. I can't think of any reason to use %zd rather than %zu to print a size_t value. It's not even valid (has undefined behavior) if the value exceeds SIZE_MAX / 2. (For completeness, you might mention %zo for octal.)
@FUZxxl: POSIX doesn't require that ssize_t is the signed type corresponding to size_t, so it's not guaranteed to match "%zd". (It probably is on most implementations.) pubs.opengroup.org/onlinepubs/9699919799/basedefs/…
J
John Bode

For C89, use %lu and cast the value to unsigned long:

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

For C99 and later, use %zu:

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

Considering 2013, suggest "For C99 and onward" & "For pre C99:". Best answer.
Do not do this. It will fail on 64 bit Windows where size_t is 64 bit and long is 32 bit.
@Yttrill: What's the answer for 64-bit windows, then?
Or: you could cast to a uint64_t and then use the PRIu64 macro from inttypes.h, which contains the format specifier.
@JamesKo what's the point in that? uint64_t is C99, so if it's available then so is "%zu" (which is the correct way to do it).
v
vulcan raven

Extending on Adam Rosenfield's answer for Windows.

I tested this code with on both VS2013 Update 4 and 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 generated binary outputs:

1 1 2

while the one generated by VS2013 says:

zu zx zd

Note: ssize_t is a POSIX extension and SSIZE_T is similar thing in Windows Data Types, hence I added <BaseTsd.h> reference.

Additionally, except for the follow C99/C11 headers, all C99 headers are available in VS2015 preview:

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

Also, C11's <uchar.h> is now included in latest preview.

For more details, see this old and the new list for standard conformance.


VS2013 Update 5 produces the same results as Update 4 gave you.
h
haccks
printf("size = %zu\n", sizeof(thing) );

s
swestrup

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.


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

Yeah, but the questioner asks specifically for a printf specifier. I'd guess that they have some other unstated constraints that make using std::cout a problem.
@Donal I wonder what kind of problem could C++ streams create in a C++ project!
@AraK. They are very slow? They add a LOT of bytes for not much reason. ArunSaha just wants to know for his/her own personal knowledge? Personal preference (I prefer stdio to fstream myself). There are many reasons.
@T.K.Crowder: Well, the original request did say that a C solution was wanted (through tagging) and there are good reasons to not use streams in C++, e.g., if the output format descriptor is being pulled from a message catalog. (You could write a parser for messages and use streams if you wanted, but that's a lot of work when you can just leverage existing code.)
@Donal: The tags were C and C++. I'm not in any way advocating C++'s I/O stream stuff (I'm not a fan of it), just pointing out that the question didn't originally *"...ask specification for a printf specifier."
K
Keith Thompson

In any reasonably modern C implementation, "%zu" is the correct way to print a value of type size_t:

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

The "%zu" format specifier was added in the 1999 ISO C standard (and adopted by the 2011 ISO C++ standard). If you don't need to be concerned about implementations older than that, you can stop reading now.

If your code needs to be portable to pre-C99 implementations, you can cast the value to unsigned long and use "%lu":

printf("sizeof (int) = %lu\n", (unsigned long)sizeof (int));

That's not portable to C99 or later, because C99 introduced long long and unsigned long long, and therefore the possibility that size_t is wider than unsigned long.

Resist the temptation to use "%lu" or "%llu" without the cast. The type used to implement size_t is implementation-defined, and if the types don't match, the behavior is undefined. Something like printf("%lu\n", sizeof (int)); might "work", but it's not at all portable.

In principle, the following should cover all possible cases:

#if __STDC_VERSION__ < 199901L
    printf("sizeof (int) = %lu\n", (unsigned long)sizeof (int));
#else
    printf("sizeof (int) = %zu\n", sizeof (int));
#endif

In practice, it might not always work correctly. __STD_VERSION__ >= 199901L should guarantee that "%zu" is supported, but not all implementations are necessarily correct, especially since __STD_VERSION__ is set by the compiler and "%zu" is implemented by the runtime library. For example, an implementation with partial C99 support might implement long long and make size_t a typedef for unsigned long long, but not support "%zu". (Such an implementation likely wouldn't define __STDC_VERSION__.)

It's been pointed out that Microsoft's implementation can have 32-bit unsigned long and 64-bit size_t. Microsoft does support "%zu", but that support was added relatively late. On the other hand, casting to unsigned long will be a problem only if the particular size_t value happens to exceed ULONG_MAX, which is unlikely to happen in practice.

If you're able to assume reasonably modern implementations, just use "%zu". If you need to allow for older implementations, here's an absurdly portable program that adapts to various configurations:

#include <stdio.h>
#include <limits.h>
int main(void) {
    const size_t size = -1; /* largest value of type size_t */
#if __STDC_VERSION__ < 199901L
    if (size > ULONG_MAX) {
        printf("size is too big to print\n");
    }
    else {
        printf("old: size = %lu\n", (unsigned long)size);
    }
#else
    printf("new: size = %zu\n", size);
#endif
    return 0;
}

One implementation that prints "size is too big to print" (x86_64-w64-mingw32-gcc.exe -std=c90 on Windows/Cygwin) actually supports unsigned long long as an extension on top of C90, so you might be able to take advantage of that -- but I can imagine a pre-C99 implementation that supports unsigned long long but doesn't support "%llu". And that implementation supports "%zu" anyway.

In my experience, I've only wanted to print size_t values in quick throwaway code when I'm exploring an implementation rather than in production code. In that kind of context, it's probably sufficient just to do whatever works.

(The question is about C, but I'll mention that in C++ std::cout << sizeof (int) will work correctly in any version of the language.)


R
Rick Berge

As AraK said, the c++ streams interface will always work portably.

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

If you want C stdio, there is no portable answer to this for certain cases of "portable." And it gets ugly since as you've seen, picking the wrong format flags may yield a compiler warning or give incorrect output.

C99 tried to solve this problem with inttypes.h formats like "%"PRIdMAX"\n". But just as with "%zu", not everyone supports c99 (like MSVS prior to 2013). There are "msinttypes.h" files floating around to deal with this.

If you cast to a different type, depending on flags you may get a compiler warning for truncation or a change of sign. If you go this route pick a larger relevant fixed size type. One of unsigned long long and "%llu" or unsigned long "%lu" should work, but llu may also slow things down in a 32bit world as excessively large. (Edit - my mac issues a warning in 64 bit for %llu not matching size_t, even though %lu, %llu, and size_t are all the same size. And %lu and %llu are not the same size on my MSVS2012. So you may need to cast + use a format that matches.)

For that matter, you can go with fixed size types, such as int64_t. But wait! Now we're back to c99/c++11, and older MSVS fails again. Plus you also have casts (e.g. map.size() is not a fixed size type)!

You can use a 3rd party header or library such as boost. If you're not already using one, you may not want to inflate your project that way. If you're willing to add one just for this issue, why not use c++ streams, or conditional compilation?

So you're down to c++ streams, conditional compilation, 3rd party frameworks, or something sort of portable that happens to work for you.


s
supercat

In most contexts where a programmer would want to output a size_t, the programmer would have a reasonable upper bound on the numerical value being output. If a programmer is e.g. outputting a message saying how large an int is, using:

printf("int is %u bytes", (unsigned)sizeof (int) );

would be for all practical purposes just as portable as, but possibly faster and smaller than:

printf("int is %zu bytes", sizeof (int) );

The only situation where such a construct could fail would be on a platform where the number of bytes worth of padding on an int is absurdly big relative to the magnitude of the largest value an unsigned int can represent (it's somewhat implausible that sizeof (int) could be larger than 65535, but even more implausible that it could be that big without unsigned having enough value bits to represent a number that's bigger than sizeof (int).


K
Kylotan

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.


Most compilers will not warn you if you pass something of the wrong size into printf. GCC is an exception. inttypes.h was defined in C99 so any C compiler that is C99 compliant will have it, which should be all of them by now. Still, you may have to turn C99 on with a compiler flag. In any case, intttypes.h doesn't define a specific format for size_t or ptrdiff_t, since they were decided to be important enough to get their own size specifiers of 'z' and 't' respectively.
If you use %lu, you should cast the size_t value to unsigned long. There is no implicit conversion (other than promotions) for arguments to printf.
p
peterchen

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.


the z size modidfier is standard C, but some libc implementations are stuck in 1990 for various reasons (eg Microsoft basically abandoned C in favour of C++ and - more recently - C#)
C99 defined the size specifier 'z' to be the size of a size_t value, and 't' to be the size of a ptrdiff_t value.
%zd is wrong, it is unsigned so it should be %zu.
p
pixelbeat

On some platforms and for some types there are specific printf conversion specifiers available, but sometimes one has to resort to casting to larger types.

I've documented this tricky issue here, with example code: http://www.pixelbeat.org/programming/gcc/int_types/ and update it periodically with info on new platforms and types.


Note that link-only answers are discouraged, SO answers should be the end-point of a search for a solution (vs. yet another stopover of references, which tend to get stale over time). Please consider adding a stand-alone synopsis here, keeping the link as a reference.
A
Andre

if you want to print the value of a size_t as a string you can do this:

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);

result is:

number: 2337200120702199116

text: Lets go fishing in stead of sitting on our but !!

Edit: rereading the question because of the down votes i noted his problem is not %llu or %I64d but the size_t type on different machines see this question https://stackoverflow.com/a/918909/1755797
http://www.cplusplus.com/reference/cstdio/printf/

size_t is unsigned int on a 32bit machine and unsigned long long int on 64bit but %ll always expects a unsigned long long int.

size_t varies in length on different operating systems while %llu is the same


casting the first 8 bytes of the char array to a unsigned long long 64bit through the size_t pointer and print them as number with the printf %I64d isn't really spectacular i know, of course i didn't at code to prevent type overflow but that's not in the scope of the question.

关注公众号,不定期副业成功案例分享
Follow WeChat

Success story sharing

Want to stay one step ahead of the latest teleworks?

Subscribe Now