C++ For Loop: Syntax and Examples

Use a for loop for a deliberate count of steps

A counter-based for loop describes repeated work using initialization, a condition, an update and a body. It is a good fit when the number of steps is known from a validated count. Our first example prints three row numbers. Before writing it, specify whether row labels start at zero or one, how many rows are required, and what should happen for zero rows. Those decisions are the contract; the loop syntax is how you encode it.

The initialization runs once when control reaches the loop. The condition is checked before each possible body execution. If true, the body runs, then the update expression runs, then the condition is checked again. When false, execution continues after the loop. A successful iteration is therefore not just body followed by body: it passes through an update and another decision. That order explains many beginner surprises about printed counters.

For for (int index{0}; index < count; ++index), the ordinary small nonnegative count controls the interval [0, count). The left endpoint is included and the right endpoint excluded. With count three, the body sees zero, one and two. Printing index + 1 can give human-friendly row labels without changing the loop's interval. Distinguish the internal counter from the displayed label so an output change does not accidentally add another iteration.

Zero iterations are a valid result

If count is zero, index starts at zero and index < count is immediately false. The body never runs, but the statement after the loop still does. With count one, the body runs once at index zero. Testing these two cases exposes a surprising number of boundary errors. Do not add a special first iteration merely because a loop looks unproductive for an empty request; zero work may be exactly the requested behavior.

Changing < to <= adds another visited value for this starting counter. With count three, index now visits three too. That fourth execution is an off-by-one error relative to a three-row contract. For container access in later lessons, an index equal to size is not an element position. A half-open interval provides a reusable mental model, but the counter's type, update direction and valid bounds still need deliberate review.

The examples constrain counts to small nonnegative values. If an external count is negative, do not silently interpret the loop's immediate stop as successful validation. Reject it before repetition. Likewise, a huge count might make a technically bounded loop impractical, and a counter update near its numeric maximum can overflow. An explicit upper limit protects the teaching program's resources and arithmetic; 'it eventually stops' is not enough of an interface contract.

Give repeated state and shared state different lifetimes

A variable declared in the initialization belongs to the loop's scope and is unavailable after the loop. A local declared inside the body is created for each body execution and ends with that block. An accumulator that must retain a running total belongs outside the body. If you initialize it to zero inside every iteration, you reset the history rather than accumulate it. Trace both declarations and updates instead of only reading the final print statement.

Use clear names for different responsibilities: index tracks position, value is the current calculation, and total summarizes completed work. Updating the counter in both the body and the update clause is legal in some cases but makes visited positions harder to reason about. Prefer one obvious progress update until a different design is required. Separate calculation from output when you want to inspect intermediate state or test a formula independently later.

The increment expression ++index advances the counter by one. For this simple integer update used alone, postfix index++ also advances it, but the two forms produce different expression values when those values are used. There is no reason to embed several counter modifications in one statement. Avoid memorizing a performance slogan about increment syntax; focus on a trace that makes every visited value and stopping condition explicit.

Nested loops multiply the work

An inner loop completes its own sequence for each outer iteration. Two outer rows and three inner columns produce six inner-body executions, not five. Each inner initialization runs again when that inner loop is reached. Use distinct row and column names instead of shadowing a counter called i. Predict the order of the output pairs before running, because a correct count alone does not prove the intended layout.

break exits the nearest enclosing loop or switch. In nested loops, a break inside the inner loop normally leaves only that inner loop, not the outer one. continue skips the remaining body of the current loop. In a for loop it still reaches the update expression before the next condition check. That difference matters when comparing the later while-loop lesson, where a skipped body statement might also skip your only progress update.

Do not use continue to hide a failed validation that should stop the whole task. Decide whether a rejected item consumes an attempt, whether a partial result is valid, and whether the program should report it. For this multiplication table, every validated requested row is processed, so no skip is needed. A straightforward loop is easier to verify than a collection of early exits introduced without a requirement.

Keep an iteration receipt, not just a screenshot

For every counter loop, record its starting value, the condition before each body execution, the values used in the body, the update and the first false condition. Your trace should explain why the number of executions matches the requested count. If an output row is missing, compare those stages before rewriting the formula. If an extra row appears, inspect the interval and label separately instead of subtracting one from an unrelated value.

The upcoming range-based loop lesson will traverse library containers directly. Do not publish or imitate an unchecked array access to make this introductory counter loop seem more useful. You can learn counted repetition safely through generated values and text output. When containers are introduced, the same boundary reasoning becomes an access precondition, and the choice between a counter loop and range-based traversal depends on the actual work required.