Displaying Characters Using the C putchar() Function

What Is putchar()?

putchar() is a standard library function declared in stdio.h that writes one single character to standard output (stdout).

#include <stdio.h>

Syntax:

int putchar(int ch);

You pass it a character, and it prints that character to the screen. Here's the simplest possible example:

#include <stdio.h>
int main() {
    putchar('H');
    putchar('i');
    putchar('!');
    putchar('\n');
    return 0;
}

Output:

Hi!

Notice there's no automatic newline — putchar() prints exactly what you give it, nothing more. If you want a line break, you have to print '\n' yourself.

A Quick Look at the Return Value

Like getchar(), putchar() returns an int. On success, it returns the character it wrote. On failure, it returns EOF.

int result = putchar('A');
if (result == EOF) {
    // something went wrong writing output
}

Honestly? For everyday programs printing to the screen, you'll almost never check this. Output failures are rare in normal use. But it becomes relevant when output is redirected to files or pipes, so it's worth knowing the return value exists — and now you do.

putchar() vs printf(): When to Use Which

Since printf() can also print single characters (printf("%c", ch)), why does putchar() even exist?

Here's the key insight: every time you call printf("%c", ch), the function has to parse the format string, find the %c, figure out what to do with it, and then print your character. putchar(ch) skips all of that.

For one character, the difference is invisible. But inside a loop printing thousands or millions of characters — processing a file, generating text, drawing ASCII art — putchar() is meaningfully faster and cleaner to read.

(Suggested image: a small "race" graphic — putchar vs printf printing characters in a loop, putchar crossing the finish line first)

Rule of thumb:

• Printing one character, especially in a loop? → putchar()
• Printing mixed content with formatting? → printf()

Printing Variables, Not Just Literals

So far we've printed fixed characters. The real power shows up when you print characters stored in variables — which is where the getchar()/putchar() partnership comes alive:

#include <stdio.h>
int main() {
    int ch;
    printf("Type a line of text, then press Enter:\n");
    while ((ch = getchar()) != '\n' && ch != EOF) {
        putchar(ch);
        // echo each character back    }
        putchar('\n');
        return 0;
    }

Sample Run:

Type a line of text, then press Enter:C is awesomeC is awesome

This is the famous echo loop — read a character, print a character, repeat. It's the same while idiom from the getchar() tutorial, and it's the foundation of nearly all character-by-character text processing in C.

The ASCII Trick: Printing Characters With Numbers

Here's where putchar() gets genuinely fun. In C, every character is really just a number under the hood — its ASCII value. 'A' is 65, 'a' is 97, '0' is 48.

Since putchar() takes an int, you can feed it numbers directly:

putchar(65);
// prints Aputchar(66);
// prints Bputchar(97);
// prints aputchar(48);
// prints 0

And that means you can print the entire alphabet with a loop — no strings required:

#include <stdio.h>
int main() {
    int ch;
    printf("Uppercase: ");
    for (ch = 'A'; ch <= 'Z'; ch++) {
        putchar(ch);
    }
    putchar('\n');
    printf("Lowercase: ");
    for (ch = 'a'; ch <= 'z'; ch++) {
        putchar(ch);
    }
    putchar('\n');
    return 0;
}

Output:

Uppercase: ABCDEFGHIJKLMNOPQRSTUVWXYZLowercase: abcdefghijklmnopqrstuvwxyz

Because 'A' to 'Z' are consecutive ASCII values (65–90), a simple loop walks through every letter. This same trick is how you'd print digits, generate tables, or build simple ciphers.

(Suggested image: a mini ASCII reference graphic showing A=65, a=97, 0=48 with a "try putchar(65)" callout)

A Practical Example: Converting Case

Let's combine everything — getchar(), putchar(), and ASCII math — into something actually useful: a program that converts text to uppercase as it reads it:

#include <stdio.h>
int main() {
    int ch;
    printf("Type a sentence (then Enter):\n");
    while ((ch = getchar()) != '\n' && ch != EOF) {
        if (ch >= 'a' && ch <= 'z') {
            putchar(ch - 32);
            // lowercase to uppercase        } else {            putchar(ch);        // everything else unchanged        }    }
            putchar('\n');
            return 0;
        }

Sample Run:

Type a sentence(then Enter):hello c programmers!HELLO C PROGRAMMERS!

Why - 32? In ASCII, the gap between an uppercase letter and its lowercase twin is exactly 32 ('a' = 97, 'A' = 65). Subtract 32, and you've converted the case — no library functions needed.

(Worth knowing: the standard library has toupper() in ctype.h that does this more safely — but seeing the manual version teaches you how characters actually work.)

Fun Bonus: Simple Terminal Graphics

Since putchar() prints exactly what you tell it, character by character, it's perfect for drawing simple shapes in the terminal:

#include <stdio.h>
int main() {
    int row, col;
    for (row = 1; row <= 5; row++) {
        for (col = 1; col <= row; col++) {
            putchar('*');
        }
        putchar('\n');
    }
    return 0;
}

Output:

***************

Two nested loops and two putchar() calls — that's a complete triangle generator. Patterns like this are classic beginner exercises, and putchar() makes them read beautifully.

Common putchar() Mistakes

1. Expecting an automatic newline — putchar() never adds one; print '\n' yourself
2. Passing a whole string — putchar("Hello") doesn't work; it takes ONE character. Use puts() or printf() for strings
3. Using double quotes instead of single — putchar("A") is wrong (that's a string); putchar('A') is right (that's a character)
4. Forgetting it returns int — matters when output is redirected and failures become possible
5. Reaching for printf("%c") out of habit — inside tight character loops, putchar() is the cleaner, faster tool

(Suggested image: "5 putchar() Mistakes" checklist graphic, matching the style of the previous pages)

The Complete Family: putchar() Alongside Its Siblings

You've now met all four basic character I/O functions in C. Here's how they fit together:

The pattern is simple: the char functions are the fast, minimal tools for single characters. The f (formatted) functions are the flexible, heavier tools for everything else. Good C programmers reach for whichever fits the job.

A Final Combined Example: Character Frequency Counter

Here's one last program that ties the whole character-I/O cluster together — it reads text and counts how many times each vowel appears:

#include <stdio.h>
int main() {
    int ch;
    int vowels = 0, consonants = 0, others = 0;
    printf("Type text (Enter, then Ctrl+Z + Enter to finish):\n");
    while ((ch = getchar()) != EOF) {
        // Normalize uppercase to lowercase for easy checking
        if (ch >= 'A' && ch <= 'Z') {
            ch = ch + 32;
        }
        if (ch=='a' || ch=='e' || ch=='i' || ch=='o' || ch=='u') {
            vowels++;
        } else if (ch >= 'a' && ch <= 'z') {
            consonants++;
        } else {
            others++;
        }
    }
    putchar('\n');
    printf("Vowels    : %d\n", vowels);
    printf("Consonants: %d\n", consonants);
    printf("Others    : %d\n", others);
    return 0;
}

Sample Run:

Type text(Enter, then Ctrl+Z + Enter to finish):
Programming in C is fun!
Vowels : 6
Consonants: 14
Others : 5

Reading, transforming, analyzing, displaying — all with the humble getchar()/putchar() pair plus one printf() for the summary. That's the entire character-I/O toolkit working as a team.

Final Thoughts

putchar() will never be the flashiest function in your programs, but it's one of those quiet workhorses you end up using everywhere once you know it exists. Character loops, ASCII manipulation, terminal patterns, text filters — it's the right tool for all of them.

Keep the essentials in mind: it prints one character, no newline, it takes an int (so ASCII numbers work), and inside loops it beats printf("%c") for both speed and readability. Pair it with getchar(), and you own character-level I/O in C.