Formatted / Unformatted I/O

Programming Language & Its Applications — Introduction to C Programming, NEC licence examination syllabus (Nepal Engineering Council).

Formatted and Unformatted I/O: how data gets in and out

printf is more configurable than most people ever discover, and scanf is more dangerous.

C has two families of I/O functions. The formatted ones (printf, scanf) interpret a format string and convert between text and binary representations. The unformatted ones (getchar, gets, puts) move characters with no conversion. The formatted family is far more useful and far more full of traps — particularly scanf, which is responsible for a large share of beginner bugs.

🌍 Where this lives: the scanf traps in this topic are the reason every experienced C programmer avoids scanf for real input and reaches for fgets. The unbounded %s below is the same flaw that made gets() so dangerous it was deleted from the C standard in 2011 — the only function ever removed. And the format-string mechanism itself has its own vulnerability class: search "format string attack %n" to see how passing user input as a format string lets an attacker write to arbitrary memory.

printf format specifiers

%d signed decimal int %u unsigned decimal %f float/double (default 6 decimal places) %e scientific notation %g shorter of %f or %e %c single character %s string (char array, NUL-terminated) %x hexadecimal (lowercase) %X uppercase %o octal %p pointer address %% a literal percent sign %zu size_t (what sizeof returns) Full form: %[flags][width][.precision][length]specifier %-10.3f → left-aligned, 10 wide, 3 decimals %+d → always show the sign %05d → pad with zeros to width 5 %ld → long int %lf → double in scanf (NOT needed in printf)

formatting.c

#include <stdio.h>

int main(void) {
    float pi = 3.14159265f;
    int   n  = 42;
    char  s[] = "NEC";

    printf("[%f]\n",     pi);   /* default 6 decimals */
    printf("[%.2f]\n",   pi);   /* 2 decimals         */
    printf("[%10.2f]\n", pi);   /* width 10, right    */
    printf("[%-10.2f]\n", pi);  /* width 10, LEFT     */
    printf("[%05d]\n",   n);    /* zero padded        */
    printf("[%+d]\n",    n);    /* forced sign        */
    printf("[%x] [%o]\n", n, n);
    printf("[%10s] [%-10s]\n", s, s);
    return 0;
}
Output:
[3.141593]
[3.14]
[      3.14]
[3.14      ]
[00042]
[+42]
[2a] [52]
[       NEC] [NEC       ]

The scanf traps

TRAP 1 — forgetting & scanf("%d", n); ✗ passes the VALUE, crashes scanf("%d", &n); ✔ passes the ADDRESS Exception: arrays already decay to a pointer, so scanf("%s", name); ✔ no & needed for a char array TRAP 2 — %s stops at whitespace Input "Manish Yadav" with scanf("%s", name) gives only "Manish". Use fgets() for a whole line. TRAP 3 — no bounds checking char small[5]; scanf("%s", small); ← typing 20 chars overflows! Fix: scanf("%4s", small); or use fgets() TRAP 4 — leftover newline scanf("%d", &n); /* leaves '\n' in the buffer */ scanf("%c", &ch); /* immediately reads that '\n' */ Fix: scanf(" %c", &ch); ← the leading space skips whitespace

The leading-space fix in scanf(" %c", &ch) is one of the most useful things to know in C. Numeric conversions leave the newline in the input buffer; %c then consumes it instead of waiting for real input, so the program appears to skip a prompt. A single space in the format string tells scanf to discard whitespace first.

Worked example — a safe input routine

safe_input.c

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

int main(void) {
    char name[50];
    int  age;

    printf("Name: ");
    if (fgets(name, sizeof name, stdin) != NULL) {
        name[strcspn(name, "\n")] = '\0';  /* strip newline */
    }

    printf("Age: ");
    if (scanf("%d", &age) != 1) {        /* CHECK the return! */
        printf("Invalid number\n");
        return 1;
    }

    printf("%s is %d years old\n", name, age);
    return 0;
}
Input:  Manish Yadav
        23
Output: Manish Yadav is 23 years old

Two safety habits shown above: 1. fgets() takes a SIZE, so it cannot overflow the buffer. Unlike gets(), which has no size parameter and was REMOVED from the C11 standard for being unfixable. 2. scanf RETURNS the number of items successfully converted. Checking it catches the case where the user typed letters instead of digits. Ignoring the return value leaves 'age' holding garbage.

Unformatted I/O functions

getchar() — read one character from stdin putchar(c) — write one character to stdout gets(s) — read a line ← NEVER USE, removed in C11 fgets(s, n, stdin) — read a line, size-limited ✔ puts(s) — write a string and add a newline Comparison: formatted → converts between text and binary, slower, flexible unformatted → moves characters verbatim, faster, no conversion

count_chars.c

#include <stdio.h>

int main(void) {
    int c, letters = 0, digits = 0, spaces = 0, other = 0;

    printf("Type text, then Ctrl-D:\n");
    while ((c = getchar()) != EOF) {   /* note: int, not char! */
        if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))
            letters++;
        else if (c >= '0' && c <= '9') digits++;
        else if (c == ' ' || c == '\n' || c == '\t') spaces++;
        else other++;
    }
    printf("letters=%d digits=%d spaces=%d other=%d\n",
           letters, digits, spaces, other);
    return 0;
}
Input:  Hello 123!
Output: letters=5 digits=3 spaces=1 other=1

Note int c, not char c. EOF is typically −1, which cannot be represented in an unsigned char and is indistinguishable from character 255 in a signed one. Declaring c as char makes the loop either never terminate or terminate early — a classic bug.

💡 Exam angle: the format-specifier table and the width/precision syntax are direct recall marks. The highest-value content is the scanf traps — the missing &, %s stopping at whitespace, and the leftover-newline problem with its leading-space fix. Mention that gets() was removed from C11 and fgets() should be used instead; that shows current knowledge.

Syllabus points

printf/scanf
getchar/putchar, gets/puts

Create a free account to tick topics off, take notes as you read, watch the video lessons and get a day-by-day study plan built around your exam date.