Format Specifiers in C: The Complete printf and scanf Reference

A format specifier tells printf how to turn a value into text, and scanf how to turn text into a value. It is the one part of C where the compiler cannot help you by default - the argument types are invisible to the function - so this page is the table to check against.

The general shape of a specification is:

%[flags][width][.precision][length]conversion

Only the % and the conversion letter are required. %-8.2lf uses all five parts.

The Conversion Table

#include <stdio.h>

int main(void) {
    int x = 255;

    printf("%%d  : %d\n", x);
    printf("%%u  : %u\n", x);
    printf("%%x  : %x\n", x);
    printf("%%X  : %X\n", x);
    printf("%%o  : %o\n", x);
    printf("%%c  : %c\n", 65);
    printf("%%s  : %s\n", "text");
    printf("%%f  : %f\n", 3.5);
    printf("%%e  : %e\n", 3.5);
    printf("%%g  : %g\n", 3.5);
    printf("%%p  : %p\n", (void *)&x);
    return 0;
}

Two entries deserve a warning. %n writes to memory rather than printing, and is the mechanism behind the format-string vulnerability - never let user text reach a format string. And %p requires a void *; passing an int * directly is undefined even though every real compiler prints the address anyway.

Length Modifiers

The length modifier goes between the precision and the conversion letter, and it says how big the argument actually is.

Signed conversions (d i) and unsigned ones (u x o) take different types - %lu wants an unsigned long, not a long, and getting that wrong is undefined behavior, not a cosmetic slip.

And for the floating-point and character families:

The combinations you actually type:

#include <stdio.h>
#include <string.h>

int main(void) {
    short              s   = -12;
    long               l   = 3000000000L;
    long long          ll  = 9000000000000000000LL;
    unsigned long      ul  = 4000000000UL;
    unsigned long long ull = 18000000000000000000ULL;
    size_t             len = strlen("hello");
    long double        ld  = 2.5L;

    printf("short              : %hd\n", s);
    printf("long               : %ld\n", l);
    printf("long long          : %lld\n", ll);
    printf("unsigned long      : %lu\n", ul);
    printf("unsigned long long : %llu\n", ull);
    printf("size_t             : %zu\n", len);
    printf("long double        : %Lf\n", ld);
    return 0;
}

%zu is the one to memorize. sizeof, strlen, and every standard-library size returns size_t, which is 8 bytes on a 64-bit system while int is 4. printf("%d", strlen(s)) is a real bug that appears to work on some platforms - use %zu.

The hh and h modifiers exist mainly for scanf, where the destination size matters. In printf a short is promoted to int before the call, so %d would print it correctly anyway; %hd merely documents the intent.

Fixed-Width Types

For <stdint.h> types like int32_t, the portable specifiers are macros from <inttypes.h>:

#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>

int main(void) {
    int32_t  a = -2000000000;
    uint64_t b = 18000000000000000000ULL;

    printf("int32_t  : %" PRId32 "\n", a);
    printf("uint64_t : %" PRIu64 "\n", b);
    return 0;
}

PRId32 expands to the right letters for your platform, and adjacent string literals concatenate, which is why the format is split into three pieces. It is ugly; the alternative - casting to long long and using %lld - is often more readable and always correct.

Flags

Flags go immediately after the % and change the presentation. They apply to printf only.

#include <stdio.h>

int main(void) {
    printf("|%6d|\n",   42);
    printf("|%-6d|\n",  42);
    printf("|%06d|\n",  42);
    printf("|%+d|\n",   42);
    printf("|% d|\n",   42);
    printf("|%#x|\n",  255);
    printf("|%#o|\n",   64);
    printf("|%#.0f|\n", 3.0);
    return 0;
}

Flags can combine: %-+8.2f is minimum width 8, two decimals, always signed, padded after the number. - beats 0 if you write both.

Width and Precision

Width is a minimum field size - the output is padded to reach it, and never truncated to fit it. Precision (after a dot) means something different for each family:

#include <stdio.h>

int main(void) {
    printf("|%10.3f|\n", 3.14159);     /* width 10, 3 decimals */
    printf("|%.5d|\n",   42);          /* minimum 5 digits     */
    printf("|%.3s|\n",   "abcdefg");   /* at most 3 chars      */
    printf("|%.0f|\n",   2.71828);     /* no decimals          */
    printf("|%*d|\n",    8, 42);       /* width from an argument */
    printf("|%.*f|\n",   3, 3.14159);  /* precision from an argument */
    return 0;
}

A * in place of either number takes it from an int argument, read before the value itself. That is how you build tables whose column widths are computed at runtime.

In scanf the width has a different and much more important job: it limits how much input a conversion will consume, which is the only thing standing between %s and a buffer overflow.

Where printf and scanf Differ

They look alike and disagree in four places. Each of these is a live bug source:

#include <stdio.h>

int main(void) {
    double d;
    char   word[16];

    printf("Enter a decimal number and a word: ");
    if (scanf("%lf %15s", &d, word) == 2) {   /* %lf and a width */
        printf("%.3f and \"%s\"\n", d, word); /* %f and a precision */
    } else {
        printf("Input did not match.\n");
    }
    return 0;
}

Try 2.5 hello. The format reading it and the format printing it use different letters for the same double, and the 15 in %15s caps the input at 15 characters plus the terminator - exactly the size of word.

The scanf Scanset

%[...] reads a set of characters rather than a whitespace-delimited word. It is the way to read a whole line with scanf, though fgets remains the better tool:

#include <stdio.h>

int main(void) {
    char line[64];

    printf("Type a sentence: ");
    if (scanf("%63[^\n]", line) == 1) {     /* everything up to a newline */
        printf("You typed: %s\n", line);
    }
    return 0;
}

[^\n] means "any characters except a newline". %[0-9] would read only digits, %[abc] only those three letters. Unlike %s, a scanset does not skip leading whitespace, so a stray newline in the buffer makes it match nothing at all.

Getting It Wrong Is Undefined Behavior

printf cannot see your argument's real type. It reads whatever number of bytes the specifier implies, interpreted however the specifier says. So a mismatch is not a formatting glitch - it is reading memory as the wrong thing:

printf("%d\n", 3.5);        /* prints garbage: reads a double's bits as int */
printf("%s\n", 42);         /* treats 42 as an address - crash */
printf("%d\n", strlen(s));  /* size_t read as int - wrong on 64-bit */
printf("%f\n", 3);          /* int read as double - garbage */

The defense costs one flag. Compile with -Wall and GCC checks every literal format string against its arguments:

gcc -Wall -Wextra program.c -o program

It reports each of the four lines above at compile time. This is the single highest-value warning in C, and it is on by default in the editor above.

For the practical side of using these - aligned tables, printing floats readably, reading input without the classic newline bug - see printf and scanf.