scanf: Reading Input Without Losing Your Mind

Bob types 12 34 into his program and it dies without printing anything. He removes one character from a line he did not write, and it works. Then he reads a letter after a number and gets a letter he never typed.

Both are the same lesson, learned twice. scanf uses the format language you already know from printf, mirrored, with one extra rule and one famous trap. This lesson is those two things and nothing else.

scanf is printf's mirror, with one extra rule

printf takes values and writes text. scanf takes text and writes values, which means it needs somewhere to put them.

Handing it a variable would hand it a copy of that variable's value, and writing into a copy changes nothing. So you hand it the address of the box instead, with an ampersand.

int items = scanf("format", &first, &second);

&x           the address of x: where x lives, not what is in it
             the one thing printf never needs and scanf always does

%d   %u      an int, an unsigned int
%ld  %lld    a long, a long long
%lf          a double.  %f here reads a float and ruins a double
%c           exactly one character, whitespace included
%s           one word, stopping at the first whitespace
%19s         the same, writing at most 19 characters plus the marker
%x   %o      a number written in base 16 or base 8

a space      in the format, skip any run of whitespace here
             " %c" is a space then %c, and it is the fix for the trap

returns      how many items were filled in.  EOF when the input ran out

So the shape is always the same: a format that mirrors the input, an ampersand on every target, and a returned count you look at.

Print what scanf gave back, every time

scanf returns the number of items it successfully filled in. Not the number of characters, and not whether the values are sensible.

Ignoring that number is the single most common beginner habit that turns a wrong input into a wrong answer instead of a clear message. Lesson 5 is about what to do with it; this lesson just prints it.

#include <stdio.h>

int main(void)
{
    int roll = 0;

    int read = scanf("%d", &roll);

    printf("scanf returned %d\n", read);
    printf("roll is %d\n", roll);
    return 0;
}

scanf returned 1
roll is 47

That output is for the input 47. One item asked for, one item filled in, so the answer is 1.

Type a word instead of a number and the first line reads 0, which is lesson 5's whole subject.

Several values at once, and whitespace in the format

A format can ask for several values. Between them you usually write a space, which means "skip any whitespace here", and that includes the newline you pressed Enter for.

So one format reads values typed on one line or on three, without changing anything.

#include <stdio.h>

int main(void)
{
    int roll = 0;
    char section = '?';
    double cgpa = 0.0;

    int read = scanf("%d %c %lf", &roll, &section, &cgpa);

    printf("scanf returned %d\n", read);
    printf("roll    : %d\n", roll);
    printf("section : %c\n", section);
    printf("cgpa    : %.2f\n", cgpa);
    return 0;
}

scanf returned 3
roll    : 47
section : B
cgpa    : 3.78

That output is for the input 47 B 3.78. It is the same for the same three values typed on three separate lines.

The space before %c is doing real work there, and the next section is why.

%c does not skip whitespace, and a newline is whitespace

Every other specifier skips leading whitespace before it starts reading. %c does not, because sometimes a space is the character you want.

That is reasonable and it causes the most reported bug in every beginner C course. Here is the sequence.

You type 47 and press Enter. %d reads the 4 and the 7, stops at the newline, and leaves it sitting in the stream. Then %c reads the next character, which is that newline.

The fix is one space in the format string. A space there means "skip any whitespace", so the cursor moves past the newline and reads the character you meant.

This is why the second read in Example 2 above was written " %c" and not "%c".

%s stops at whitespace, and does not know when to stop writing

%s reads one word: it skips leading whitespace, then takes characters until the next whitespace. It cannot read a line with spaces in it, and reading a whole line is Module 10.

The dangerous half is what it does at the other end. A bare %s writes as many characters as arrive, whether or not there is room for them.

The fix is a width: %19s writes at most 19 characters, plus the marker C puts at the end of every piece of text. Nineteen and a marker fit in twenty boxes.

#include <stdio.h>

int main(void)
{
    char word[20] = {0};
    char initial = '?';

    int first = scanf("%19s", word);
    int second = scanf(" %c", &initial);

    printf("first scanf returned  %d, word is %s\n", first, word);
    printf("second scanf returned %d, initial is %c\n", second, initial);
    return 0;
}

first scanf returned  1, word is Progsity
second scanf returned 1, initial is R

That output is for the input Progsity R. Arrays are Module 9 and text is Module 10, so treat char word[20] as twenty boxes in a row for now.

Notice there is no ampersand on word. An array's name already is an address, which is the one exception to the ampersand rule and the reason Module 9 and Module 11 exist.

%lf for a double, always, and only here

In a printf, %f prints both a float and a double, because a float is widened on its way into the call.

In a scanf nothing is widened, because you are handing over an address and the address says nothing about the size. %f means "write four bytes here" and %lf means "write eight".

Use %f for a double and scanf writes four bytes into an eight byte box. The value is wrong, nothing is reported on the Playground, and the number you print is usually zero.

So the rule is short: in a scanf, a double is %lf, every time.

#include <stdio.h>

int main(void)
{
    int a = 0;
    int b = 0;

    int read = scanf("%d %d", &a, &b);

    printf("read %d value(s)\n", read);
    printf("%d + %d = %d\n", a, b, a + b);
    return 0;
}

read 2 value(s)
12 + 34 = 46

#include <stdio.h>

int main(void)
{
    int roll = 0;
    char section = '?';

    int first = scanf("%d", &roll);
    int second = scanf(" %c", &section);

    printf("returned %d and %d\n", first, second);
    printf("roll %d, section [%c], as a number %d\n", roll, section, section);
    return 0;
}

returned 1 and 1
roll 47, section [B], as a number 66

#include <stdio.h>

int main(void)
{
    char name[20] = {0};
    int roll = 0;
    char section = '?';
    double cgpa = 0.0;

    int read = scanf("%19s %d %c %lf", name, &roll, &section, &cgpa);

    printf("fields read : %d\n", read);
    printf("%-10s%6d%4c%8.2f\n", name, roll, section, cgpa);
    return 0;
}

fields read : 4
Nusrat        47   B    3.78

int roll = 0;
scanf("%d", roll);

scanf("%d", &roll);
scanf("%c", &section);

double cgpa = 0.0;
scanf("%f", &cgpa);

char word[20] = {0};
scanf("%s", word);

#include <stdio.h>

int main(void)
{
    int roll = 0;
    char section = '?';

    int first = scanf("%d", roll);
    int second = scanf(" %c", &section);

    printf("%d %d\n", first, second);
    printf("roll %d, section %c\n", roll, section);
    return 0;
}

#include <stdio.h>

int main(void)
{
    int a = 0;
    int b = 0;
    scanf("%d %d", &a, &b);

    /* Two printf calls. The product does not fit in an int. */

    return 0;
}

#include <stdio.h>

int main(void)
{
    char name[20] = {0};

    int read = scanf("%19s", name);

    /* Two lines: the greeting, then what scanf gave back. */

    return 0;
}

#include <stdio.h>

int main(void)
{
    int roll = 0;
    char section = '?';
    double cgpa = 0.0;

    int read = scanf("%d %c %lf", &roll, &section, &cgpa);

    /* Three printf calls, then one more line printing read. */

    return 0;
}

#include <stdio.h>

int main(void)
{
    double a = 0.0;
    double b = 0.0;
    double c = 0.0;
    scanf("%lf %lf %lf", &a, &b, &c);

    /* One printf. Divide by 3.0 and not by 3, and ask yourself why. */

    return 0;
}

Next you stop assuming the read worked, and make the returned count do some actual work.