🌱 C Basics

for loops: init, test, step — all in one line

⏱ 13 min · free interactive lesson · quizzes, visualizations & a real compiler

Last lesson's healthy-loop checklist — initialize, test, update — is so universal that C gives it a shorthand of its own. The for loop puts all three on one line, where you can't forget any of them:

#include <stdio.h>

int main(void) {
    int sum = 0;

    for (int i = 1; i <= 100; i++) {
        sum += i;
    }
    printf("1 + 2 + ... + 100 = %d\n", sum);
    return 0;
}

$ gcc sum100.c -o sum100 && ./sum100
1 + 2 + ... + 100 = 5050
# young Gauss computed this in his head; your CPU does it in nanoseconds

for (init; condition; step) runs like this — note it's exactly a while loop in a tailored suit:

▶ This spot has an interactive flow widget — open the interactive lesson to play with it.

• init runs once, before anything else. Declaring the variable right there (int i = 1) is standard since C99.
• condition is tested before every iteration — first one included.
• step runs after each body, just before the next test.

Watch all three phases fire in order:

▶ This spot has an interactive trace widget — open the interactive lesson to play with it.

The loop variable's tiny life

Declare i in the init clause and it exists only inside the loop — after the closing brace, i is gone, and mentioning it is a compile error. This is a feature: each loop gets a fresh, private counter, and no stale counters leak around your function.

Nested loops: the times table

A loop body can contain another loop. The inner loop runs to completion for every single iteration of the outer one — 10 × 10 = 100 inner bodies here:

#include <stdio.h>

int main(void) {
    for (int row = 1; row <= 10; row++) {
        for (int col = 1; col <= 10; col++) {
            printf("%4d", row * col);
        }
        printf("\n");        /* end the row */
    }
    return 0;
}

$ gcc timestable.c -o tt && ./tt
   1   2   3   4   5   6   7   8   9  10
   2   4   6   8  10  12  14  16  18  20
   3   6   9  12  15  18  21  24  27  30
   4   8  12  16  20  24  28  32  36  40
   5  10  15  20  25  30  35  40  45  50
   6  12  18  24  30  36  42  48  54  60
   7  14  21  28  35  42  49  56  63  70
   8  16  24  32  40  48  56  64  72  80
   9  18  27  36  45  54  63  72  81  90
  10  20  30  40  50  60  70  80  90 100
# %4d right-aligns each number in 4 columns — instant neat table

Two counters at once: the comma operator

The init and step clauses each accept only one expression — but the comma operator chains several into one, evaluating left to right. It's the idiomatic way to walk two indices together (you'll meet it again reversing arrays in Part 2):

#include <stdio.h>

int main(void) {
    /* two counters marching toward each other */
    for (int lo = 0, hi = 9; lo < hi; lo++, hi--) {
        printf("lo=%d hi=%d\n", lo, hi);
    }
    return 0;
}

$ gcc comma.c -o comma && ./comma
lo=0 hi=9
lo=1 hi=8
lo=2 hi=7
lo=3 hi=6
lo=4 hi=5

▶ This spot has an interactive editor widget — open the interactive lesson to play with it.

You can now start loops — next you'll learn to escape them early: break, continue, and the infamous goto.