Why must I use %zu for size_t?

size_t is an unsigned type whose width varies by platform, so printing it with %u or %lu is undefined behaviour on systems where the sizes differ. The z length modifier with u, as in %zu, tells printf the argument is exactly a size_t.

What is the difference between %x and %X?

Both print an unsigned integer in hexadecimal. %x uses lowercase digits a to f, while %X uses uppercase A to F. The alternate flag %#x or %#X adds a 0x or 0X prefix.

How do I print a long long?

Use the ll length modifier: %lld for a signed long long and %llu for unsigned. A single l only covers long, which may be narrower, so passing a long long to %ld is undefined behaviour on many platforms.

What does the precision mean for strings versus floats?

For %s the precision is the maximum number of characters to print, so %.5s prints at most five. For %f the precision is the number of digits after the decimal point, so %.2f prints two. Default float precision is six.

Why is passing the wrong type undefined behaviour?

printf is variadic and reads arguments according to the format string, not the actual types. If the specifier says %d but you pass a double, printf reads the wrong number of bytes and interprets them wrongly, which can crash or print garbage. Compiler warnings catch many of these.

What is the C/C++ printf Format Specifiers?

Reference for C and C++ printf and scanf format specifiers — %d, %u, %x, %f, %e, %g, %s, %c, %p, %%, plus length modifiers (l, ll, h, z, j) and width/precision flags — with the exact argument type each expects. It runs free in your browser on Gera Tools, with nothing uploaded.

C/C++ printf Format Specifiers

Name: C/C++ printf Format Specifiers
Creator: Gera Tools
License: https://creativecommons.org/licenses/by/4.0/

C’s printf and scanf families are driven by format specifiers — a percent sign, optional flags, width, precision, and a length modifier, ending in a conversion letter. Because these functions are variadic, a mismatch between the specifier and the argument type is undefined behaviour. This tool is a searchable reference of every specifier and the exact type it expects.

How it works

A full specifier has the shape %[flags][width][.precision][length]conversion. The conversion letter picks the base behaviour; the rest refine it:

Integer conversions — %d/%i (signed decimal), %u (unsigned), %o (octal), %x/%X (hex), %c (character), %hhd…%lld with length modifiers.
Floating conversions — %f/%F, %e/%E, %g/%G, %a/%A (hex float).
Other — %s (string), %p (pointer), %% (literal percent), %n (store count — dangerous, often disabled).
Length modifiers — hh (char), h (short), l (long), ll (long long), z (size_t), j (intmax_t), t (ptrdiff_t), L (long double).

Worked example

int   n = 42;       printf("%d\n", n);        // 42
unsigned u = 42;    printf("%#x\n", u);       // 0x2a
double d = 3.14159; printf("%8.3f\n", d);     // "   3.142"
size_t len = 7;     printf("%zu\n", len);     // 7
long long big = 9e9;printf("%lld\n", big);    // 9000000000
char *s = "hello";  printf("%.3s\n", s);      // hel

Flags in detail

Flags come immediately after the % and modify the output style:

Flag	Effect
`-`	Left-justify in the field width (default is right)
`+`	Always print a sign, even for positive numbers
space	Print a leading space for positive numbers
`#`	Alternate form: `0x` prefix for hex, `0` for octal, always decimal point for floats
`0`	Pad with zeros instead of spaces for numeric fields

Combining flags: %-8d produces a left-aligned 8-character signed integer field; %+.2f forces a sign on a two-decimal float.

Common type mismatches that cause undefined behaviour

The most frequent type errors with printf:

Passing a long to %d (should be %ld) — undefined on 64-bit Windows where long is 32-bit but on 64-bit Linux where long is 64-bit can silently truncate.
Passing a size_t to %u instead of %zu — undefined on platforms where size_t is wider than unsigned int.
Passing a double where %Lf expects a long double — different sizes, different calling conventions.
Passing NULL to %s — many implementations print “(null)” but the C standard does not guarantee this; it is undefined behaviour.

Enable compiler warnings (-Wall -Wformat in GCC/Clang) to catch most format mismatches at compile time.

Notes

%i and %d are identical in printf but differ in scanf, where %i auto-detects the base from a 0x/0 prefix and %d is decimal only.
For scanf, every non-%c/%s argument must be a pointer: scanf("%d", &n). Forgetting the & is a frequent crash.
%n writes the number of characters output so far through a pointer argument; it is a security risk and is disabled by hardened libc builds.
Width and precision can be passed dynamically with *, consuming an int argument: printf("%*.*f", 8, 3, d).
snprintf is always preferred over sprintf — it writes at most n bytes including the null terminator, preventing buffer overflows.