Loops in C: Understanding Repetitive Program Execution

The Anatomy of Every Loop

Despite their different personalities, all three loops share the same four parts:

1. Initialization — set up a starting point (e.g., i = 1)
2. Condition — checked to decide whether the loop continues (e.g., i <= 5)
3. Body — the code that repeats
4. Update — something that moves the loop toward ending (e.g., i++)

Here's the most important sentence in this tutorial:

If the condition never becomes false, the loop never ends.

Forget the update step, or write a condition that can't fail, and you've built an infinite loop — the program runs forever (or until you kill it with Ctrl+C). Every loop bug you've ever heard of traces back to one of these four parts being wrong.

Loop #1: for — The Counter

for is the organized one. All four parts visible at a glance, three of them packed into the header line:

for (initialization;
condition;
update) {
    // body
}

In action:

#include <stdio.h>
int main() {
    for (int i = 1;
    i <= 5;
    i++) {
        printf("Hello %d\n", i);
    }
    return 0;
}

Output:

Hello 1Hello 2Hello 3Hello 4Hello 5

Read the header as a sentence: "Start i at 1; keep looping while i is at most 5; add 1 after each pass." The condition is checked before every iteration — so for (int i = 10; i <= 5; i++) would run zero times without complaint.

Personality: use for when you know how many times you need to repeat. Counting, tables, array processing (soon!), fixed repetitions.

Loop #2: while — The Condition-Watcher

while strips the loop down to its essence — just a condition and a body:

while (condition) {
    // body — and YOU handle the update inside
}

Initialization happens before the loop; the update happens inside the body. It's your responsibility not to forget them:

#include <stdio.h>
int main() {
    int countdown = 5;
    // initialization
    while (countdown > 0) {
        // condition        printf("%d...\n", countdown);        countdown--;            // update — forget this and it loops forever!    }
        puts("Liftoff! 🚀");
        return 0;
    }

Output:

5...4...3...2...1...Liftoff! 🚀

Like for, the condition is checked before each pass — so a while loop can run zero times. Where while truly shines is when you don't know the count in advance: reading input until the user quits, retrying until input is valid, processing data until it runs out:

int number = 0;
while (number >= 0) {
    // no idea how many times this will run    printf("Enter a number (negative to stop): ");
    scanf("%d", &number);
}
puts("Done!");

Personality: use while when repetition depends on a condition, not a count.

Loop #3: do-while — The Optimist

The odd sibling flips the script: body first, condition after.

do {
    // body — always runs AT LEAST ONCE
} while (condition);

That reversal is the entire point. A do-while guarantees one execution minimum, no matter what:

#include <stdio.h>
int main() {
    int pin;
    do {
        printf("Enter your 4-digit PIN: ");
        scanf("%d", &pin);
    } while (pin != 4321);
    puts("Access granted!");
    return 0;
}

Sample Run:

Enter your 4-digit PIN: 1111Enter your 4-digit PIN: 0000Enter your 4-digit PIN: 4321Access granted!

The prompt must happen before there's anything to check — a while loop would need an awkward workaround; do-while says it naturally. Don't miss the semicolon after while (condition); — it's required here, and forgetting it is a classic compile error.

Personality: use do-while when the body must run at least once — menus, input prompts, "play again?" logic.

(Suggested image: three-panel flowchart comparison — for and while checking BEFORE the body, do-while checking AFTER. The single most useful visual on this page.)

The Three Loops Side by Side

Same task — printing 1 to 5 — three ways:

// forfor (int i = 1; i <= 5; i++) {    printf("%d ", i);}
// whileint i = 1;while (i <= 5) {    printf("%d ", i);    i++;}
// do-whileint j = 1;do {    printf("%d ", j);    j++;} while (j <= 5);

All three print 1 2 3 4 5. Which proves an important truth: any loop can imitate any other. The choice isn't about capability — it's about which one makes your intent obvious to the reader.

The Infinite Loop: Bug and Tool

When the condition can never become false, the loop runs forever:

// ACCIDENTAL infinite loops:int i = 1;
while (i <= 5) {
    printf("%d ", i);
    // forgot i++ — i is 1 forever
}
for (int k = 0;
k < 10;
k--) {
    // wrong direction! k goes 0, -1, -2...    printf("%d ", k);
}

These are bugs — the program hangs, fans spin, Ctrl+C saves the day. But here's the twist: programmers deliberately write infinite loops all the time:

while (1) {
    // 1 is always true — loop forever...    showMenu();
    int choice = readChoice();
    if (choice == 0) {
        break;
        // ...until this exits
    }
}

A menu, a game, a server — anything that should run "until the user quits" is naturally an infinite loop with a break escape hatch. while (1) plus break isn't sloppy code; it's a standard idiom.

break and continue: The Loop Controls

Two statements manage loops from the inside (each gets its own deep-dive later in this cluster):

break — leave the loop entirely:

for (int i = 1;
i <= 10;
i++) {
    if (i == 6) {
        break;
        // exit completely at 6
    }
    printf("%d ", i);
}
// Output: 1 2 3 4 5

continue — skip the rest of this pass, start the next:

for (int i = 1;
i <= 10;
i++) {
    if (i % 2 == 0) {
        continue;
        // skip even numbers
    }
    printf("%d ", i);
}
// Output: 1 3 5 7 9

One line to remember: break leaves the loop; continue skips ahead within it.

Loops Can Nest Too

Just like if statements, loops live inside each other — an inner loop runs completely for every single pass of the outer one:

for (int row = 1;
row <= 3;
row++) {
    for (int col = 1;
    col <= 4;
    col++) {
        printf("[%d,%d] ", row, col);
    }
    printf("\n");
}

Output:

[1,1] [1,2] [1,3] [1,4][2,1] [2,2] [2,3] [2,4][3,1] [3,2] [3,3] [3,4]

3 outer passes × 4 inner passes = 12 iterations total. Nested loops are how you'll print patterns, process tables, and (later) walk through multi-dimensional arrays.

A Complete Example: Multiplication Table Generator

Decisions + loops + formatting — the series coming together:

#include <stdio.h>
int main() {
    int number, upto;
    printf("Which table? ");
    scanf("%d", &number);
    printf("Up to? ");
    scanf("%d", &upto);
    if (upto <= 0) {
        puts("Range must be positive!");
        return 1;
    }
    printf("\n=== Table of %d ===\n", number);
    for (int i = 1; i <= upto; i++) {
        printf("%3d × %2d = %4d\n", number, i, number * i);
    }
    return 0;
}

Sample Run:

Which table? 7Up to? 5
=== Table of 7 === 7 × 1 = 7 7 × 2 = 14 7 × 3 = 21 7 × 4 = 28 7 × 5 = 35

A for loop doing counted repetition, an if guarding against silly input, and %3d/%2d/%4d width formatting from our printf deep-dive keeping every column aligned. Real programs are always a blend like this.

The Five Classic Loop Mistakes

1. The missing update — condition never changes, loop never ends. Suspect it first whenever a program hangs.
2. The stray semicolon — for (i = 0; i < 5; i++); loops five times doing nothing, then the body runs once after. That semicolon is an empty statement.
3. Off-by-one errors — < 5 gives you 0–4 (five passes); <= 5 gives you 0–5 (six). When a loop runs once too many or too few, the comparison operator is the culprit.
4. Wrong update direction — counting down (i--) toward a condition that needs counting up. The condition stays true forever.
5. Modifying the loop variable inside the body of a for loop — legal, but it turns predictable counting into chaos. Let the header do the counting.

(Suggested image: "5 Loop Mistakes" checklist graphic — consistent with the series)

Final Thoughts

Loops are where C starts feeling like magic: three lines of code doing the work of three million. The whole topic reduces to one picture — a body of code and a condition, with an arrow looping back — plus one rule: make sure the condition can become false.

Remember the personalities: for counts, while watches, do-while guarantees one run. Choose by intent, not habit. And when a program freezes on you, smile — you've just met your first infinite loop, a rite of passage every C programmer shares.

Next in the series, we zoom in on each loop individually, starting with the workhorse: the for loop.