When Input Goes Wrong: Checking What You Read

Maria's till asks for an amount and somebody types twelve. The till prints a receipt anyway. The number on it is not twelve and it is not zero. She asks where it came from, and nobody in the shop can tell her.

This lesson is one idea from end to end. scanf already told the program that nothing was read, and the program threw that away. Everything below is what happens next, and what you do instead.

The returned value is a count, and EOF is not a count

Three answers come back from a read of one value, and they mean three different things.

The first two are easy to confuse and the difference matters. A 0 means a word arrived where a number was expected, and that word is still waiting. A -1 means nothing arrived at all, and nothing ever will.

EOF is a macro from <stdio.h>. On this toolchain it is -1, which is why a program that prints the returned value prints -1 at the end of its input.

With several specifiers the count goes up to the number of items filled, and it stops at the first one that fails. A three specifier read returning 2 means the third one did not happen.

A failed read leaves your variable exactly as it was

This is the part nobody is told, and it is what makes Maria's receipt so confusing.

When a read fails, scanf does not zero the variable, does not clear it, and does not touch it. Whatever value the variable held before the call, it still holds after.

#include <stdio.h>

int main(void)
{
    int amount = -1;

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

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

scanf returned 0
amount is now  -1

That output is for the input twelve. The -1 on the second line is the -1 from the declaration, untouched.

Run the same program on the input 42 and it prints 1 and 42. The variable is the same variable; only the count told you which of the two stories happened.

So a sensible starting value is not tidiness, it is the answer your program will print when the read fails. Choose it on purpose.

The character that failed is still in the stream

The second half of the surprise. A failed %d does not consume the text that did not match. The t of twelve is still the next character waiting.

So the next %d meets the same t, fails in the same way, and returns 0 again. A program that retries without clearing the stream retries forever.

#include <stdio.h>

int main(void)
{
    int amount = -1;
    char stuck = '?';

    int first = scanf("%d", &amount);
    int second = scanf("%d", &amount);
    int third = scanf(" %c", &stuck);

    printf("first  read returned %d\n", first);
    printf("second read returned %d\n", second);
    printf("third  read returned %d and got [%c]\n", third, stuck);
    printf("amount is still %d\n", amount);
    return 0;
}

first  read returned 0
second read returned 0
third  read returned 1 and got [t]
amount is still -1

That output is for the input twelve. Read the third line: the character the two number reads choked on is the letter t, and a %c picks it up happily.

That is the proof. The stream never moved, because %d only consumes characters it can use.

Clearing the rest of the bad line properly needs a loop, which is Module 6. Reading one bad character out of the way, as above, is what you can do today.

A range check without an if: print the comparison

Knowing the read worked is half of checking input. The other half is whether the value makes sense, and that is a comparison.

Module 2 lesson 4 said a comparison is an expression worth 1 or 0. That is all you need to report a check, even though acting on it is Module 5's job.

Joining two checks with && is Module 4, so until then two checks are two lines.

#include <stdio.h>

int main(void)
{
    const int LOWEST = 1;
    const int HIGHEST = 100;
    int marks = 0;

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

    printf("read ok     : %d\n", read == 1);
    printf("at least %3d : %d\n", LOWEST, marks >= LOWEST);
    printf("at most  %3d : %d\n", HIGHEST, marks <= HIGHEST);
    return 0;
}

read ok     : 1
at least   1 : 1
at most  100 : 0

That output is for the input 150. The read worked, the value is above the lowest allowed, and it is not below the highest.

Now run it on twelve and read the answer carefully.

read ok     : 0
at least   1 : 0
at most  100 : 1

The third line says the value is inside the band. It is, because the variable still holds the 0 the declaration gave it, and 0 is at most 100.

That is the whole reason the first line exists. A range check on a value that was never read is an answer about your own initialiser. It looks exactly like an answer about the input.

So the order is fixed: ask whether the read worked, and only then ask whether the value is sensible.

fgets, in one paragraph

There is a different way to read input, and it avoids most of this lesson. fgets takes a whole line, spaces and all, into an array of characters, and then you pick it apart yourself.

It never leaves a half read number in the stream, because it always consumes a whole line. Module 10 teaches it properly, once text is a thing you can work with.

Until then, scanf plus its returned count is the honest tool, and it is what every judge problem in this track uses.

What a judge does with wrong output

A judge runs your program on an input it holds, captures everything you printed, and compares it with the expected output character by character.

It does not know what you meant. A value that is right and a line that is one space wrong are the same verdict as a value that is nonsense.

That cuts both ways, and it is why this module has spent two lessons on printing exactly. It also means a program that prints a sensible answer for bad input is not rewarded for it.

On a judge the input is always valid, because the statement promised it. The return value still matters, because the same program run by a person is not so lucky.

#include <stdio.h>

int main(void)
{
    int n = 0;

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

    printf("returned %d\n", read);
    printf("value %d\n", n);
    return 0;
}

returned 1
value 12

#include <stdio.h>

int main(void)
{
    int roll = 0;
    int marks = 0;
    int bonus = 0;

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

    printf("fields read : %d\n", read);
    printf("roll  : %d\n", roll);
    printf("marks : %d\n", marks);
    printf("bonus : %d\n", bonus);
    return 0;
}

fields read : 2
roll  : 47
marks : 88
bonus : 0

#include <stdio.h>

int main(void)
{
    const int LOWEST = 0;
    const int HIGHEST = 100;
    int marks = -1;

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

    printf("read ok  : %d\n", read == 1);
    printf("in range : %d\n", (marks >= LOWEST) * (marks <= HIGHEST));
    printf("usable   : %d\n", (read == 1) * (marks >= LOWEST) * (marks <= HIGHEST));
    return 0;
}

read ok  : 1
in range : 1
usable   : 1

int amount = 0;
scanf("%d", &amount);
printf("total: %d\n", amount * 2);

int marks;
scanf("%d", &marks);
printf("%d\n", marks);

int n = 0;
scanf("%d", &n);
scanf("%d", &n);

int marks = 0;
scanf("%d", &marks);
printf("%d\n", marks <= 100);

#include <stdio.h>

int main(void)
{
    int amount = -1;

    int first = scanf("%d", &amount);
    int second = scanf("%d", &amount);

    printf("%d %d %d\n", first, second, amount);
    return 0;
}

#include <stdio.h>

int main(void)
{
    int amount = 0;

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

    /* Two lines. Print what scanf gave back, then what is in the box. */

    return 0;
}

#include <stdio.h>

int main(void)
{
    int low = 0;
    int high = 0;
    int reading = 0;
    scanf("%d %d %d", &low, &high, &reading);

    /* Two lines, each a comparison printed with %d. No if anywhere. */

    return 0;
}

#include <stdio.h>

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

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

    /* Three printf calls. Nothing decides anything. */

    return 0;
}

Next you put all five lessons together on ten graded problems, where the judge is the only opinion that counts.