Using the while Loop in C for Condition-Based Repetition

The Syntax

while (condition) {
    // body — repeats while condition is true
}

That's the whole thing. Two parts:

1. condition — checked before every iteration; any non-zero value means "keep going"
2. body — the code that repeats

Everything else — initialization, updates — is your responsibility, placed before and inside the loop where needed:

int i = 1;
// initialization: BEFORE the loop
while (i <= 5) {
    // condition: checked first, every time    printf("%d ", i);
    // body    i++;
    // update: INSIDE the body — your job!
}
// Output: 1 2 3 4 5

Compare that to the for loop's all-in-one header. Same result, different organization — and that organizational difference is the whole story of when to use which.

Execution Order, Step by Step

1. Check the condition     ├─ false → EXIT immediately (body may never run at all!)     └─ true  → run the body2. Back to step 1

Two consequences to internalize:

The check comes first — always. If the condition is false from the start, the body executes zero times:

int x = 100;
while (x < 10) {
    // 100 < 10 is false immediately    puts("This never prints.");
}
puts("Skipped entirely.");

Nothing updates automatically. There's no built-in i++ like the for header. Forget your update, and the condition never changes:

int i = 1;
while (i <= 5) {
    printf("%d ", i);
    // forgot i++ — i is 1 forever. INFINITE LOOP.
}

This is the #1 while bug, and every C programmer has a personal memory of it. The for loop reminds you about the update; while trusts you completely — for better and worse.

Where while Shines: The Sentinel Pattern

The pattern while was born for: repeat until a special value says stop. That stopping value is called a sentinel:

#include <stdio.h>
int main() {
    int number;
    int sum = 0, count = 0;
    puts("Enter numbers to add (0 to stop):");
    while (1) {
        printf("> ");
        scanf("%d", &number);
        if (number == 0) {
            break;
            // sentinel found — get out        }
            sum += number;
            count++;
        }
        printf("Sum = %d, Count = %d\n", sum, count);
        if (count > 0) {
            printf("Average = %.2f\n",(float)sum / count);
        }
        return 0;
    }

Sample Run:

Enter numbers to add(0 to stop):> 10> 25> 15> 0Sum = 50, Count = 3Average = 16.67

How many numbers will the user enter? Three? Thirty? Three hundred? The program doesn't care — it loops until the sentinel (0) arrives. Try writing this with for and you'll feel the awkwardness immediately; for wants a count it can't have.

There's a classic "pure while" version of this pattern too, which avoids break by priming the loop:

int number;
printf("> ");
scanf("%d", &number);
// priming read — BEFORE the loop
while (number != 0) {
    sum += number;
    count++;
    printf("> ");
    scanf("%d", &number);
    // next read at the END of the body}

Both styles are everywhere in real code. The primed version is elegant; the while(1) + break version keeps the input code in one place. Pick per situation.

(Suggested image: a diagram of the sentinel pattern — "read → check sentinel → process → read → check..." with the loop visible)

The Input Validation Loop

The second great while pattern — refuse to continue until the user behaves:

int age;
printf("Enter your age (1-120): ");
scanf("%d", &age);
while (age < 1 || age > 120) {
    printf("Invalid! Age must be 1-120. Try again: ");
    scanf("%d", &age);
}
printf("Age recorded: %d\n", age);

Sample Run:

Enter your age(1-120): 250Invalid! Age must be 1-120. Try again: -5Invalid! Age must be 1-120. Try again: 34Age recorded: 34

The loop is the gatekeeper — the program literally cannot proceed past it with bad data. (Combine this with the scanf return-value check from our scanf tutorial for a truly bulletproof version.)

The Digit Tricks: Classic while Exercises

Some problems are pure while magic. This one reverses any number:

#include <stdio.h>
int main() {
    int num, reversed = 0;
    printf("Enter a number: ");
    scanf("%d", &num);
    while (num != 0) {
        int digit = num % 10;
        // grab the last digit        reversed = reversed * 10 + digit;        num = num / 10;              // chop the last digit off    }
        printf("Reversed: %d\n", reversed);
        return 0;
    }

Sample Run:

Enter a number: 1234Reversed: 4321

Trace it for 123: digit 3 → reversed 3; digit 2 → reversed 32; digit 1 → reversed 321; then num hits 0 and the loop ends. Notice you never knew how many digits there were — the loop just chewed until nothing remained. Counting digits, summing digits, checking palindromes — this % 10 / / 10 pair is the foundation of dozens of classic exercises.

while vs for: The Honest Comparison

The one-line rule: if you can say "loop N times," use for. If you can only say "loop until..." — that's a while.

The Five Classic while Mistakes

1. The missing update — the infinite loop hall-of-famer. Program hangs? Check this first.
2. The stray semicolon — while (i <= 5); loops forever on an empty body (the semicolon is the body!), and your real code below never runs:
   main.c

   Copy Code Run Online

   while (i <= 5);
   // ← disaster
   {
       i++;
       // never reached
   }

3. Initializing inside the loop — while (i <= 5) { int sum = 0; ... } resets sum every iteration. Initialization belongs before the loop.
4. Assuming the body runs at least once — it doesn't; that's do-while (next tutorial). False-from-the-start means zero passes.
5. Complex conditions that can never turn false — while (x != 10) when x jumps by 2 starting from 1 skips right past 10... forever. When a loop misbehaves, print the variable each iteration and watch what it's actually doing.

(Suggested image: "5 while Mistakes" checklist graphic, consistent with the series)

A Complete Example: ATM PIN with Limited Attempts

#include <stdio.h>
int main() {
    const int CORRECT_PIN = 4321;
    int pin, attempts = 0;
    int maxAttempts = 3;
    while (attempts < maxAttempts) {
        printf("Enter PIN (%d attempt%s left): ",
        maxAttempts - attempts,
(maxAttempts - attempts) == 1 ? "" : "s");
        scanf("%d", &pin);
        if (pin == CORRECT_PIN) {
            puts("Access granted. Welcome back!");
            break;
        }
        puts("Wrong PIN.");
        attempts++;
    }
    if (attempts == maxAttempts) {
        puts("Card blocked. Contact your bank.");
    }
    return 0;
}

Sample Run:

Enter PIN(3 attempts left): 1111
Wrong PIN.
Enter PIN(2 attempts left): 2222
Wrong PIN.
Enter PIN(1 attempt left): 4321
Access granted. Welcome back!

Condition-driven looping (attempts < maxAttempts), an early exit on success (break), and even a ternary for the singular/plural "attempts" — a genuinely realistic program built entirely from this series' tools.

Final Thoughts

The while loop is programming's honest repeater: it makes no promises about counts, just a simple vow — "as long as this is true, I'll keep going." Give it a condition that can change, remember your update, and it will faithfully handle everything from input validation to number crunching to game loops.

Hold onto the two big ideas: check first, body second (so zero iterations is always on the table), and the update is your responsibility. Master those, and the only thing left in this family is the loop that guarantees a first run — the do-while, coming next.