Mastering printf() in C: Syntax, Arguments, and Output Examples

What Exactly Is printf()?

printf() stands for "print formatted". It's a function from the C standard library (stdio.h) that displays formatted output on the screen.

The key word there is formatted. printf() doesn't just dump text — it lets you control how that text looks: where variables appear, how many decimal places show, how wide columns are, and more.

To use it, you always need this line at the top of your program:

#include <stdio.h>

No header, no printf(). The compiler won't know what you're talking about.

The Syntax of printf()

Here's the general form:

printf("format string", argument1, argument2, ...);

It has two parts:

1. The format string — the text inside double quotes. This can contain plain text, format specifiers (like %d), and escape sequences (like \n).
2. The arguments — the variables or values you want to insert into the string, listed after the comma.

(Suggested image: an annotated diagram — printf("I am %d years old", age); with labels pointing to "format string", "format specifier", and "argument")

Simple example:

#include <stdio.h>
int main() {
    printf("Learning C is fun!\n");
    return 0;
}

Output:

Learning C is fun!

No variables here — just plain text. But things get interesting when we add arguments.

How Arguments Work in printf()

Each format specifier in the string acts as a placeholder. When the program runs, printf() replaces each placeholder with the matching argument, in order.

#include <stdio.h>
int main() {
    char name[] = "Ravi";
    int age = 20;
    printf("My name is %s and I am %d years old.\n", name, age);
    return 0;
}

Output:

My name is Ravi and I am 20 years old.

Notice the order matters: %s grabs name, %d grabs age. If you swap the arguments, you'll get garbage output — or a crash. printf() won't warn you; it just trusts you.

The Complete List of Format Specifiers

This is the heart of printf(). Memorize these (or bookmark this page — no judgment).

(Suggested image: a colorful infographic version of this table — great for Pinterest and social sharing)

Escape Sequences: Controlling the Layout

Escape sequences are special character combos (starting with \) that control formatting inside the string.

Example:

printf("Name:\tRavi\nAge:\t20\n");

Output:

Name: RaviAge: 20

The \t lines everything up neatly — handy for printing simple tables without any extra work.

The Part Most Tutorials Skip: Width and Precision

This is where printf() goes from basic to genuinely useful.

Setting Field Width

Put a number between % and the specifier to set a minimum width:

printf("%5d\n", 42);
// Output: "   42" (right-aligned in 5 spaces)printf("%-5d|\n", 42);
// Output: "42   |" (left-aligned, note the minus sign)

Controlling Decimal Precision

For floats, use .n to control decimal places:

float pi = 3.14159265;
printf("%f\n", pi);
// 3.141593  (default: 6 decimals)printf("%.2f\n", pi);
// 3.14printf("%.4f\n", pi);
// 3.1416

Combining Width and Precision

printf("%8.2f\n", 3.14159);
// "    3.14" — 8 wide, 2 decimals

This is exactly how you'd print a clean, aligned price list or marks table:

printf("%-10s %8.2f\n", "Apples", 45.50);
printf("%-10s %8.2f\n", "Oranges", 60.00);
printf("%-10s %8.2f\n", "Mangoes", 120.75);

Output:

Apples 45.50Oranges 60.00Mangoes 120.75

Neat, right? No fancy libraries needed.

(Suggested image: side-by-side comparison — messy unaligned output vs. clean aligned output using width specifiers)

A Few More Useful Tricks

Printing a literal percent sign:

printf("Discount: 25%%\n");
// Output: Discount: 25%

Zero-padding numbers:

printf("%05d\n", 42);
// Output: 00042

Showing the sign of a number:

printf("%+d\n", 42);
// Output: +42

Printing in hexadecimal (great for debugging):

int n = 255;
printf("%x\n", n);
// Output: ff

Common printf() Mistakes Beginners Make

1. Wrong specifier for the data type — using %d for a float prints garbage. Match them carefully.
2. Missing arguments — writing printf("%d %d", x); with only one value leads to undefined behavior.
3. Forgetting \n — your output runs into the next line and looks messy.
4. Using %s on a non-string — this usually crashes the program.
5. Expecting compiler warnings — many compilers won't catch specifier mismatches by default. Compile with -Wall to get helpful warnings.

(Suggested image: "5 printf() Mistakes" checklist-style graphic)

A Complete Example Putting It All Together

#include <stdio.h>
int main() {
    char name[] = "Priya";
    int roll = 7;
    float marks = 92.4567;
    printf("===== Student Report =====\n");
    printf("Name  : %-10s\n", name);
    printf("Roll  : %03d\n", roll);
    printf("Marks : %.2f / 100\n", marks);
    printf("Grade : %c\n", 'A');
    printf("Pass  : 100%%\n");
    return 0;
}

Output:

===== Student Report =====
Name : Priya
Roll : 007
Marks : 92.46 / 100
Grade : A
Pass : 100%

One function, five different formatting techniques. That's the real power of printf().

Final Thoughts

printf() looks simple on the surface, but there's real depth hiding in those format specifiers. Once you're comfortable with width, precision, and alignment, you'll find yourself writing cleaner, more readable output without any extra effort.

My honest advice: don't just read these examples — type them out, break them on purpose, and see what happens. Feed printf() the wrong specifier and watch the garbage it prints. That kind of hands-on messing around teaches you more than any tutorial ever will.