Input and Output in C: printf, scanf, and Stream Functions Explained

One of the very first things I had to learn in C — before loops, before functions, even before I fully understood variables — was how to get data into my program and how to get results back out. That’s the world of input and output (I/O), and honestly, it’s a topic that seems trivially simple on the surface (just call printf, right?) but has surprising depth once you start digging into format specifiers, buffering, streams, and file handling.

In this article, I’ll walk you through everything I’ve learned about I/O in C: the basics of printf and scanf, the lesser-used but powerful stream functions, how buffering actually works in memory, common mistakes that trip up almost every beginner (myself included), and how to write efficient, safe I/O code.

Table of Contents

1. Understanding I/O in C: The Concept of Streams
2. The printf Function
3. Format Specifiers in Detail
4. The scanf Function
5. Character I/O: getchar, putchar
6. String I/O: gets/fgets, puts
7. File I/O: fopen, fread, fwrite, fclose
8. Internal Working: Buffering and Memory Behavior
9. Best Practices
10. Performance Optimization
11. Common Mistakes and Debugging Tips
12. Real-World Applications
13. Interview Questions
14. FAQs
15. Summary and Key Takeaways
16. References

1. Understanding I/O in C: The Concept of Streams

In C, all input and output is handled through an abstraction called a stream. A stream is essentially a sequence of bytes flowing between my program and some source or destination — a keyboard, a monitor, a file, or even another program. C doesn’t care whether the stream is connected to a file on disk or to the terminal; it treats them uniformly through the FILE* type defined in <stdio.h>.

By default, every C program automatically has three standard streams available:

• stdin — standard input (usually the keyboard)
• stdout — standard output (usually the terminal screen)
• stderr — standard error (also usually the terminal, but unbuffered and meant for error messages)

Every I/O function I use — printf, scanf, fopen, fread — ultimately operates on these FILE* streams.

2. The printf Function

printf (short for “print formatted”) is how I send output to stdout. Here’s the basic syntax:

#include <stdio.h>

int main() {
    int age = 25;
    float height = 5.9;
    char grade = 'A';

    printf("Age: %d, Height: %.1f, Grade: %c\n", age, height, grade);
    return 0;
}

Output:

Age: 25, Height: 5.9, Grade: A

printf takes a format string as its first argument, containing regular text mixed with format specifiers (like %d, %f, %c) that act as placeholders for the variables passed afterward. The function returns an int — the number of characters printed, or a negative value on error — though I rarely check this return value in simple programs.

3. Format Specifiers in Detail

Understanding format specifiers thoroughly saved me from countless subtle bugs. Here are the most common ones:

Here’s a program demonstrating several of these together:

#include <stdio.h>

int main() {
    int num = 255;
    printf("Decimal: %d\n", num);
    printf("Hexadecimal: %x\n", num);
    printf("Octal: %o\n", num);
    printf("Percent literal: 100%%\n");
    return 0;
}

Output:

Decimal: 255
Hexadecimal: ff
Octal: 377
Percent literal: 100%

I also use width and precision modifiers to control formatting:

#include <stdio.h>

int main() {
    printf("[%10d]\n", 42);     // Right-aligned in a 10-character field
    printf("[%-10d]\n", 42);    // Left-aligned in a 10-character field
    printf("[%05d]\n", 42);     // Zero-padded to 5 digits
    printf("[%8.3f]\n", 3.14159); // Width 8, 3 decimal places
    return 0;
}

Output:

[        42]
[42        ]
[00042]
[   3.142]

4. The scanf Function

scanf is the counterpart to printf, used to read formatted input from stdin.

#include <stdio.h>

int main() {
    int age;
    printf("Enter your age: ");
    scanf("%d", &age);
    printf("You entered: %d\n", age);
    return 0;
}

Sample interaction:

Enter your age: 25
You entered: 25

Notice the & before age — this is critical. scanf needs the address of the variable to write into, because C passes arguments by value, and without the address, scanf would have no way to modify the original variable. Forgetting the & is one of the most common beginner mistakes (I’ll cover this more in the mistakes section).

scanf returns the number of items it successfully read, which I always recommend checking in real production code:

#include <stdio.h>

int main() {
    int age;
    printf("Enter your age: ");
    if (scanf("%d", &age) != 1) {
        printf("Invalid input!\n");
        return 1;
    }
    printf("You entered: %d\n", age);
    return 0;
}

5. Character I/O: getchar, putchar

For reading and writing single characters, C provides getchar() and putchar().

#include <stdio.h>

int main() {
    char ch;
    printf("Enter a character: ");
    ch = getchar();
    printf("You entered: ");
    putchar(ch);
    putchar('\n');
    return 0;
}

Sample interaction:

Enter a character: A
You entered: A

I find these especially useful when writing simple parsers or reading input character by character in a loop, like this classic pattern for counting characters until EOF:

#include <stdio.h>

int main() {
    int ch;
    long count = 0;

    while ((ch = getchar()) != EOF) {
        count++;
    }

    printf("Total characters read: %ld\n", count);
    return 0;
}

Notice I declared ch as int, not char. This is intentional — getchar() returns an int so it can represent the special EOF value (typically -1), which wouldn’t fit distinctly if ch were an unsigned char.

6. String I/O: gets/fgets, puts

Reading full lines of text is a common need. The old gets() function is now deprecated and removed from the C standard because it doesn’t check buffer size, making it a major security risk (a classic cause of buffer overflow vulnerabilities). I always use fgets() instead:

#include <stdio.h>

int main() {
    char name[50];

    printf("Enter your name: ");
    fgets(name, sizeof(name), stdin);

    printf("Hello, %s", name);
    return 0;
}

Sample interaction:

Enter your name: John
Hello, John

One quirk: fgets includes the newline character (\n) in the buffer if there’s room, so I often strip it manually:

name[strcspn(name, "\n")] = '\0';

For output, puts() is a simple alternative to printf for printing a string followed by a newline:

puts("Hello, World!"); // automatically adds \n

7. File I/O: fopen, fread, fwrite, fclose

Beyond the console, C lets me read and write files using the same stream-based approach.

#include <stdio.h>

int main() {
    FILE *fp = fopen("data.txt", "w");
    if (fp == NULL) {
        printf("Error opening file!\n");
        return 1;
    }

    fprintf(fp, "Hello, File!\n");
    fclose(fp);

    // Now read it back
    char buffer[100];
    fp = fopen("data.txt", "r");
    if (fp != NULL) {
        fgets(buffer, sizeof(buffer), fp);
        printf("Read from file: %s", buffer);
        fclose(fp);
    }

    return 0;
}

Output:

Read from file: Hello, File!

For binary data, I use fread and fwrite instead of the text-based functions:

#include <stdio.h>

struct Point {
    int x, y;
};

int main() {
    struct Point p1 = {10, 20};

    FILE *fp = fopen("point.bin", "wb");
    fwrite(&p1, sizeof(struct Point), 1, fp);
    fclose(fp);

    struct Point p2;
    fp = fopen("point.bin", "rb");
    fread(&p2, sizeof(struct Point), 1, fp);
    fclose(fp);

    printf("x = %d, y = %d\n", p2.x, p2.y);
    return 0;
}

Output:

x = 10, y = 20

Always checking the return value of fopen for NULL is something I never skip, since a missing file or permission error will silently crash your program otherwise (via a NULL pointer dereference).

8. Internal Working: Buffering and Memory Behavior

This is the part most tutorials gloss over, but it genuinely changed how I think about I/O performance.

Streams are buffered. When I call printf, the output doesn’t necessarily go straight to the terminal — it’s usually placed into an internal buffer maintained by the C standard library, and only flushed (actually sent) to the OS when:

• The buffer becomes full,
• The program calls fflush() explicitly,
• The stream is closed (e.g., via fclose or at program exit),
• Or, in the case of stdout connected to a terminal, when a newline character is encountered (this is called line buffering).

There are three buffering modes in C:

• Fully buffered: Data is flushed only when the buffer is full or flushed manually. Typically used for file streams.
• Line buffered: Data is flushed after each newline. Typically used for stdout connected to a terminal.
• Unbuffered: Data is sent immediately. This is the default for stderr, ensuring error messages appear right away, even if the program crashes right after.

I can control this manually using setvbuf():

setvbuf(stdout, NULL, _IOFBF, 1024); // fully buffered, 1024-byte buffer

Why does this matter for memory? The buffer itself is a chunk of memory (often allocated on the heap by the standard library the first time you use the stream) that temporarily holds bytes before they’re written via a system call like write(). This buffering exists because system calls are expensive — grouping many small writes into fewer, larger system calls significantly improves performance. This is why, if a program crashes before flushing, buffered output that hasn’t been flushed can be lost — something I learned painfully while debugging a program that seemed to “not print anything” before a segmentation fault, when in reality the output was sitting in a buffer that never got flushed.

Compiler process consideration: printf and scanf are variadic functions (they accept a variable number of arguments), implemented using <stdarg.h> macros internally in the C library. The compiler doesn’t type-check the arguments against the format string by default in strict C (though GCC provides a helpful -Wformat warning that does check this at compile time) — this is why passing the wrong type to a format specifier is a runtime bug, not a compile error, unless you enable these warnings.

9. Best Practices

1. Always check the return value of scanf to ensure the expected number of items were read.
2. Never use gets() — always use fgets() instead, since gets has no way to prevent buffer overflow.
3. Match format specifiers exactly to variable types — using %d for a long or %f for a double in scanf causes undefined behavior.
4. Always check fopen‘s return value for NULL before using the file pointer.
5. Always fclose() every file you fopen(), ideally as soon as you’re done with it, to flush buffers and release OS resources.
6. Clear leftover input in the buffer when mixing scanf("%d", ...) with fgets calls, since scanf leaves the trailing newline in the input buffer.
7. Use %.*f style precision for user-facing decimal output, so numbers display consistently.
8. Prefer snprintf over sprintf to prevent buffer overflows when formatting into a fixed-size buffer.

10. Performance Optimization

• Minimize the number of I/O calls. Each call to printf or fprintf (especially unbuffered ones) can be relatively costly; where possible, build a string in memory and print it once instead of calling printf many times in a loop.
• Use buffered I/O for large file operations. Reading/writing in large chunks with fread/fwrite is dramatically faster than reading one byte or one line at a time for bulk data.
• Avoid unnecessary fflush() calls, since flushing forces an actual system call, negating the performance benefit of buffering.
• For high-performance logging, consider using a larger buffer size via setvbuf to reduce the frequency of underlying write() system calls.
• Use fwrite/fread with binary mode for structured data instead of parsing text with fscanf, since binary I/O skips the overhead of text formatting and parsing.

11. Common Mistakes and Debugging Tips

Mistake 1: Forgetting & in scanf

int age;
scanf("%d", age); // WRONG! Missing &, causes undefined behavior / crash

Fix: scanf("%d", &age);

Mistake 2: Leftover newline in the input buffer

int age;
char name[50];

scanf("%d", &age);
fgets(name, sizeof(name), stdin); // This often reads an empty line!

This happens because pressing Enter after typing the age leaves a \n character in the input buffer, which fgets immediately picks up as an “empty line.” Fix: consume the leftover newline explicitly, for example with while (getchar() != '\n'); after the scanf call.

Mistake 3: Using gets() This function is dangerous because it has no bounds checking and has been removed from the C11 standard entirely. Always use fgets().

Mistake 4: Mismatched format specifiers

double pi = 3.14;
printf("%d\n", pi); // WRONG! %d expects int, not double - undefined behavior

Fix: Use %f or %lf for printf with floating types (note printf treats %f and %lf the same due to default argument promotion, but scanf requires the distinction).

Mistake 5: Not checking fopen for NULL

FILE *fp = fopen("missing.txt", "r");
fgets(buffer, 100, fp); // Crashes if fp is NULL!

Debugging tips:

• Compile with -Wall -Wformat to catch format specifier mismatches at compile time.
• Use fflush(stdout) before a potential crash point to make sure buffered output actually appears, helping you localize where a crash occurs.
• When debugging scanf input issues, print the returned value of scanf to check how many fields were actually matched.
• Use tools like Valgrind to catch buffer overflows in string handling.

12. Real-World Applications

• Command-line utilities that read input from users or pipe data through stdin/stdout.
• Configuration file parsers that use fscanf or line-based reading with fgets.
• Logging systems that write structured log entries to files using buffered I/O for performance.
• Data serialization using binary fwrite/fread for saving/loading program state (like game saves).
• Embedded systems where UART or serial communication is often abstracted through similar stream-like read/write functions.
• Network programs where the concept of streams (though using sockets rather than FILE*) mirrors the same buffering principles.

13. Interview Questions

1. What is the difference between printf and fprintf?
2. Why does scanf require the address-of operator & for its arguments?
3. What are the differences between gets() and fgets(), and why is gets() considered unsafe?
4. Explain the concept of buffering in C I/O. What are the three types of buffering?
5. Why does getchar() return an int instead of a char?
6. What happens when you mix scanf("%d", ...) with fgets() calls?
7. How would you check whether a file was opened successfully?
8. What is the difference between text mode and binary mode file I/O in C?
9. What does EOF represent, and how is it typically implemented?
10. How can you flush an output stream manually, and when would you need to?

14. FAQs

Q: Why does scanf("%d", &age) sometimes skip subsequent input? A: This usually happens because a previous input left a newline character in the buffer, which the next read operation immediately consumes. Clearing the input buffer resolves this.

Q: Is printf guaranteed to print immediately? A: No. Due to buffering, output may be delayed until the buffer fills, a newline is encountered (in line-buffered mode), or the stream is flushed/closed.

Q: What’s the difference between %f and %lf in printf vs scanf? A: In printf, both are treated identically for a double due to default argument promotion rules. In scanf, you must use %lf for a double and %f for a float, since scanf doesn’t perform this promotion.

Q: Why was gets() removed from the C standard? A: Because it provides no way to limit the number of characters read, making it inherently vulnerable to buffer overflows — a serious and long-exploited security risk.

Q: What is stderr used for, and why is it unbuffered by default? A: stderr is meant for error messages, and it’s unbuffered so that if a program crashes immediately after an error is reported, the message still appears — nothing is left sitting in a buffer that never gets flushed.

15. Summary and Key Takeaways

Input and output in C revolve around the abstraction of streams, accessed through FILE* pointers. printf and scanf are the everyday workhorses for formatted console I/O, while getchar/putchar and fgets/puts handle character and line-based I/O respectively. File operations extend this same stream model to persistent storage using fopen, fread, fwrite, and fclose. Underneath all of this lies a buffering system that batches data to minimize expensive system calls — understanding fully buffered, line buffered, and unbuffered modes helped me write both correct and performant I/O code.

Key takeaways:

• Always match format specifiers precisely to variable types.
• Never use gets() — use fgets() instead.
• Remember the & when using scanf on ordinary variables.
• Check return values from scanf and fopen to catch errors early.
• Understand buffering so you know when output is actually written versus just queued in memory.

16. References

• ISO/IEC 9899 — Programming Languages: C (the official ISO C Standard), Section 7.21 on the Input/Output <stdio.h> library.
• GNU C Library (glibc) Documentation on standard streams and buffering, gnu.org/software/libc/manual/
• GCC Documentation on Warning Options (-Wformat, -Wall), gcc.gnu.org/onlinedocs/gcc/

Mastering I/O in C might feel basic at first glance, but as you’ve seen, there’s a lot happening beneath printf("Hello, World!\n") — buffers, streams, system calls, and careful type matching all working together. Once I understood these mechanics, I stopped treating I/O as an afterthought and started writing safer, faster C programs.