What You Will Learn

• What the scanf field width means, and how it differs from the width in printf
• The four rules scanf follows every time it applies a width
• How %wd, %wf and %ws behave when the input is shorter than, equal to, or longer than the width
• Why leftover characters stay in the input buffer and how they affect the next read
• How to size a character array correctly for %ns and avoid overflow
• How to use widths with sscanf to parse packed data such as GPS time and dates

Prerequisites

• You have read the earlier lectures in this chapter on conversion specifiers and basic printf and scanf use
• You know what an int, a float and a char array are
• GCC installed (every program here was built with GCC 13 on Ubuntu 24.04 using -std=c11)

What Is scanf Field Width in C?

A scanf conversion has several optional parts: %, an optional *, an optional width, an optional length modifier such as l, and finally the conversion letter. The width is a positive decimal number. Written as %5s, it means: “read at most five characters for this item, then stop.”

The word to remember is maximum. A scanf field width never pads, never inserts blanks and never forces scanf to wait for more characters. If the item ends early (because a space or a letter shows up), scanf is happy to stop early. The width only matters when the input is long enough to hit the limit.

This is the opposite of what the same number means in printf, where the width is a minimum and short values get padded. Students mix the two up constantly, so keep this table close.

How scanf Applies a Field Width: Four Rules

Whatever the conversion letter is, scanf walks through the same routine for every item that carries a width.

1. Skip leading whitespace. For %d, %f and %s, spaces, tabs and newlines in front of the item are discarded first. They do not count toward the width.
2. Read while the characters still fit the item and the count is below the width. For %d that means an optional sign followed by digits; for %s it means anything that is not whitespace.
3. Convert and store. The characters collected become an integer, a float or a string. For %s, scanf also appends the terminating '\0'.
4. Leave everything else alone. Characters that were not consumed remain in the input buffer. The next conversion, or the next scanf call, starts exactly there.

scanf Field Width with %d: Shorter, Equal, Longer

Let us read two integers with "%2d%3d". The first number may use at most two characters, the second at most three. Notice there is no space between the two conversions: with widths in place, none is needed, because scanf already knows where the first item must end.

#include <stdio.h>

int main(void)
{
    int a = -1, b = -1, ch;

    int n = scanf("%2d%3d", &a, &b);
    printf("assigned=%d  a=%d  b=%d\n", n, a, b);

    printf("left in buffer: [");
    while ((ch = getchar()) != EOF && ch != '\n')
        putchar(ch);
    printf("]\n");
    return 0;
}

The last loop is a debugging trick worth keeping. It prints whatever scanf left unread on the line, so you can literally see the buffer. Build and run it:

gcc -std=c11 -Wall -Wextra -o w_int w_int.c
./w_int

Type 483 9021 and press Enter. Here is what a run looks like for several inputs:

The fourth row is the one that surprises people. The user typed a three-digit number and a four-digit number, yet b became 3. Nothing is broken: %2d took “48”, and %3d found only “3” before the space ended its item. The four digits 9021 are still waiting in the buffer, and a later scanf call would happily pick them up.

scanf Field Width with %f: The Decimal Point Counts

For floating-point input the width counts every character of the item: digits before the point, the point itself, digits after it, a leading sign, and even an exponent. Beginners often assume the width counts only digits. It does not.

#include <stdio.h>

int main(void)
{
    float x = -1.0f, y = -1.0f;
    int ch;

    int n = scanf("%4f%5f", &x, &y);
    printf("assigned=%d  x=%.3f  y=%.3f\n", n, x, y);

    printf("left in buffer: [");
    while ((ch = getchar()) != EOF && ch != '\n')
        putchar(ch);
    printf("]\n");
    return 0;
}

gcc -std=c11 -Wall -Wextra -o w_float w_float.c
./w_float

Look at the fourth row. The programmer wanted 123.456 but got 123.0 and then a stray 456. A width that is too small does not raise an error; it silently chops the number into pieces. For this reason, most real programs leave the width off %f entirely and only use it when the data format truly has a fixed character count.

scanf Field Width with %s: Protecting Your Buffers

This is the most important use of a scanf field width. A plain %s reads until whitespace, however long the word is. If the destination array is smaller than the word, scanf writes past the end of the array and corrupts memory. That is the classic buffer overflow, and it has caused real security vulnerabilities in embedded firmware and desktop software alike. (The old gets() function was removed from the language in C11 for exactly this reason.)

A width on %s limits how many characters are stored. The golden rule: the array must be one element larger than the width, because scanf adds a '\0' after the characters.

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

int main(void)
{
    char tag[6];     /* 5 characters + 1 for '\0' */
    char rest[16];
    int ch;

    int n = scanf("%5s %15s", tag, rest);
    printf("assigned=%d  tag=[%s]  rest=[%s]\n", n, tag, rest);
    printf("strlen(tag)=%zu\n", strlen(tag));

    printf("left in buffer: [");
    while ((ch = getchar()) != EOF && ch != '\n')
        putchar(ch);
    printf("]\n");
    return 0;
}

gcc -std=c11 -Wall -Wextra -o w_str w_str.c
./w_str

The word was cut after five characters, the array stayed safe, and the remaining text became the input for the next conversion. Cutting a word in two is a trade-off, but it is a far better failure than overwriting the stack.

Letting a Constant Control the Width

Unlike printf, scanf has no * trick to take the width from a variable. The width must be a literal inside the format string. To avoid keeping a number in two places, use the preprocessor to turn a constant into text:

#include <stdio.h>

#define NAME_LEN 7
#define STR_(x) #x
#define STR(x)  STR_(x)

int main(void)
{
    char name[NAME_LEN + 1];

    if (scanf("%" STR(NAME_LEN) "s", name) == 1)
        printf("name=[%s]\n", name);
    return 0;
}

gcc -std=c11 -Wall -Wextra -o w_macro w_macro.c
echo firmware | ./w_macro

name=[firmwar]

Change NAME_LEN once and both the array size and the format string follow. The two-level STR and STR_ macros are needed so that NAME_LEN is expanded to 7 before it is turned into the text “7”.

Real-World Use: Parsing Packed Data with sscanf

Everything above works the same for sscanf, which reads from a string instead of the keyboard. This is where field widths shine, because many embedded data formats have no separators at all. Digits are simply packed side by side.

#include <stdio.h>

int main(void)
{
    const char *date = "20261022";   /* YYYYMMDD, no separators */
    const char *gps  = "123519";     /* hhmmss as in a GPS sentence */
    int y, mo, d, hh, mm, ss;

    if (sscanf(date, "%4d%2d%2d", &y, &mo, &d) == 3)
        printf("Date: %02d-%02d-%04d\n", d, mo, y);

    if (sscanf(gps, "%2d%2d%2d", &hh, &mm, &ss) == 3)
        printf("Time: %02d:%02d:%02d\n", hh, mm, ss);
    return 0;
}

gcc -std=c11 -Wall -Wextra -o w_packed w_packed.c
./w_packed

Date: 22-10-2026
Time: 12:35:19

A note for those heading toward drivers: kernel code has its own sscanf that understands field widths too, but for parsing a single number from user space (for example in a sysfs store handler) modern kernel code prefers kstrtoint() and friends, which reject trailing garbage. You will meet both in our free Linux device drivers course.

Common Mistakes and Troubleshooting

Best Practices, Performance and Security

• Always put a width on %s and %[, sized as array length minus one.
• Check the value returned by scanf and sscanf before using the variables.
• Use widths on numbers only when the data format is truly fixed-width; otherwise let the number end naturally at the first space.
• For serious input handling, read a full line with fgets into a buffer and parse it with sscanf. You get one place to check for errors and nothing is left in the stream.
• Performance: scanf is convenient but not fast. When you must read large volumes, for example sensor logs with thousands of lines, fgets plus strtol or strtod is noticeably quicker and reports errors more precisely.
• Security: untrusted input plus unbounded %s equals a vulnerability. A width is the cheapest fix there is.

Quick Quiz: Predict the Output

Click each question to reveal the answer. Try to answer before you open it.

Interview Questions

Summary and Key Takeaways

A field width is a tiny piece of syntax with big consequences. Used on %s, it is a safety belt. Used on numbers inside sscanf, it lets you slice packed data such as GPS time or compact dates without any separators. Used carelessly, it chops numbers into surprising pieces and leaves stray characters behind. The best habit you can build is to run the small programs in this lecture, change the input, and watch the “left in buffer” line until the behaviour feels obvious.

In the next lecture we switch to the output side and look at the width and precision of printf, where the same number means something very different.

Frequently Asked Questions