{"title":"For Loop","description":null,"content":"A `for` loop runs the same block of code a known number of times. It's the tool you reach for when you can answer the question \"how many iterations?\" before the loop starts: print every item in a cart, charge five customers, count down from ten to one. This lesson covers the classic C-style `for` loop, its three parts, the scope rules around the loop variable, common patterns like counting down and stepping by two, nested loops, and the bugs that show up most often.\n\n---\n\n# The Three Parts of a For Loop\n\nThe classic `for` loop has three pieces inside the parentheses, separated by semicolons, and then a body in braces.\n\n\n```cpp\nfor (init; condition; update) {\n body\n}\n```\n\n\nEach piece has a job:\n\n- **init** runs once, before the loop starts. It usually declares a counter variable.\n- **condition** is checked before every iteration. If it's `true`, the body runs. If it's `false`, the loop exits.\n- **update** runs after every iteration, just before the next condition check.\n\nHere's a `for` loop that prints the receipt for a small shopping cart:\n\n\n```cpp\n#include \n\nint main() {\n double prices[] = {19.99, 4.49, 12.00, 7.50};\n\n for (int i = 0; i < 4; i++) {\n std::cout << \"Item \" << (i + 1) << \": $\" << prices[i] << std::endl;\n }\n\n return 0;\n}\n```\n\n\nReading the loop header: start with `i = 0`, keep going while `i < 4`, and add one to `i` after each pass. The body runs four times, with `i` taking on the values `0`, `1`, `2`, `3`.\n\nThat four-iteration pattern is the most common shape of a `for` loop you'll write in C++. It walks an index from `0` up to (but not including) some limit, which lines up exactly with how arrays and `std::vector` are indexed.\n\n\n> **INFO**\n>\n> **Note on the post-increment `i++`:** For built-in types like `int`, `i++` and `++i` behave identically as loop updates. There's an old convention to write `++i` because for user-defined types the pre-increment can be cheaper, but for plain integers the compiler emits the same code either way.\n\n\n---\n\n# Execution Order\n\nThe order in which the three pieces run is not obvious from looking at the syntax. The init runs once, then for every iteration the condition runs, then the body, then the update, then the condition again. The loop exits the first time the condition returns `false`, before the body runs.\n\n\n```mermaid\nflowchart TD\n A[Start]:::cyan --> B[Run init
once]:::orange\n B --> C{Check
condition}:::green\n C -- true --> D[Run body]:::teal\n D --> E[Run update]:::orange\n E --> C\n C -- false --> F[Exit loop]:::red\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef teal fill:#38d9a9,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n classDef red fill:#ff8787,stroke:#000,color:#000\n```\n\n\nThe arrow from update back up to condition is the key insight. The condition is checked once at the start and then again after every iteration's update step. That's why a `for` loop's body might run zero times: if the condition is false the very first time it's checked, the body is skipped entirely.\n\n\n```cpp\n#include \n\nint main() {\n int itemsInCart = 0;\n for (int i = 0; i < itemsInCart; i++) {\n std::cout << \"This will never print.\" << std::endl;\n }\n std::cout << \"Loop is done.\" << std::endl;\n return 0;\n}\n```\n\n\n`itemsInCart` is `0`, so `i < itemsInCart` is `0 < 0`, which is `false`. The body never runs. The init still runs once though, because init runs before the first condition check.\n\n---\n\n# Scope of the Loop Variable\n\nA variable declared inside the init part of a `for` loop is local to the loop. It exists from the start of the init expression until the closing brace of the loop body, and not a millisecond longer.\n\n\n```cpp\n#include \n\nint main() {\n for (int i = 0; i < 3; i++) {\n std::cout << \"Inside loop: \" << i << std::endl;\n }\n\n // std::cout << i << std::endl; // compile error: 'i' is out of scope\n std::cout << \"After loop.\" << std::endl;\n return 0;\n}\n```\n\n\nIf you uncomment the line that reads `i` after the loop, `g++` rejects it with `error: 'i' was not declared in this scope`. The compiler is right: `i` was born inside the `for` header and died at the matching `}`. The name no longer refers to anything.\n\nThis is helpful, not annoying. It means two adjacent `for` loops can reuse the name `i` without stepping on each other, and it means the counter can't accidentally be read by code that runs after the loop is supposed to be done.\n\nIf you need the counter to outlive the loop (you want to know how far the loop got), declare the variable before the loop and only initialize it in the header:\n\n\n```cpp\n#include \n\nint main() {\n int prices[] = {12, 8, 25, 4, 19};\n int i = 0;\n int target = 25;\n\n for (; i < 5; i++) {\n if (prices[i] == target) {\n break;\n }\n }\n\n std::cout << \"Found target at position: \" << i << std::endl;\n return 0;\n}\n```\n\n\nHere `i` is declared in the surrounding scope, so it's still visible after the loop. The loop header leaves the init part empty (just a bare `;`) because `i` is already declared. We'll come back to empty init/condition/update in a moment.\n\nFor now, all you need to know about `break` is that it exits the loop immediately.\n\n---\n\n# All Three Parts Are Optional\n\nC++ lets you leave any of the three parts of the header empty. You still need the two semicolons, but each piece is a separate, optional expression. The most extreme version is:\n\n\n```cpp\nfor (;;) {\n // runs forever, until something inside breaks out\n}\n```\n\n\nThat's an infinite loop. With no condition, the loop never decides to stop, so it relies on a `break`, a `return`, or some other escape inside the body. You'll see this pattern when reading input from a user until they type \"quit\", or when running an event loop.\n\nA small concrete version:\n\n\n```cpp\n#include \n\nint main() {\n int countdown = 3;\n for (;;) {\n if (countdown == 0) {\n break;\n }\n std::cout << \"Shipping in \" << countdown << \"...\" << std::endl;\n countdown--;\n }\n std::cout << \"Shipped!\" << std::endl;\n return 0;\n}\n```\n\n\nThe loop runs forever in principle, but the `break` inside the body exits when `countdown` reaches `0`. This particular shape is fine for examples, but in real code a `while (countdown > 0)` reads more clearly. The point of `for (;;)` is just to show that the header pieces aren't mandatory.\n\nYou can also omit them individually. Each row below is a valid `for` loop:\n\n\n```cpp\nint i = 0;\nfor (; i < 5; i++) { /* init omitted, i declared above */ }\n\nfor (int j = 0; ; j++) { /* condition omitted, body must break */ }\n\nfor (int k = 0; k < 5;) { /* update omitted, body must change k */ }\n```\n\n\nMost loops use all three parts, because that's exactly the shape `for` was designed for. The empty forms are tools you use occasionally, not your default.\n\n---\n\n# Multiple Variables with the Comma Operator\n\nThe init and update parts each accept a single expression, but the comma operator lets you pack several into one. The most common use is walking two indices toward each other from opposite ends of a sequence.\n\n\n```cpp\n#include \n\nint main() {\n int prices[] = {10, 20, 30, 40, 50, 60, 70};\n int n = 7;\n\n for (int i = 0, j = n - 1; i < j; i++, j--) {\n std::cout << \"Pair: \" << prices[i] << \" and \" << prices[j] << std::endl;\n }\n\n return 0;\n}\n```\n\n\nTwo things to notice. First, the init declares both `i` and `j` on the same line. They must have the same type (here, `int`), because a single declaration can only declare variables of one type. Second, the update does `i++, j--`, which moves the two indices toward each other.\n\nThe loop stops when `i` and `j` meet in the middle. With seven elements, the middle index `3` is never paired, which is the correct behavior if you're walking inward.\n\nYou can also use comma in the init to combine a declaration with an unrelated initializer, but most of the time the use case is two counters moving together. A different pattern: a running total alongside an index.\n\n\n```cpp\n#include \n\nint main() {\n double prices[] = {9.99, 14.50, 3.25, 22.00};\n\n double total = 0.0;\n for (int i = 0; i < 4; i++, total += prices[i - 1]) {\n // body intentionally empty\n }\n\n std::cout << \"Cart total: $\" << total << std::endl;\n return 0;\n}\n```\n\n\nThat's clever, but cramming the work into the update makes the loop hard to read. A regular `for` loop with the addition in the body is clearer:\n\n\n```cpp\ndouble total = 0.0;\nfor (int i = 0; i < 4; i++) {\n total += prices[i];\n}\n```\n\n\nThe comma operator is genuinely useful for the two-pointers-from-both-ends pattern. For most other cases, keeping the body honest is the right call.\n\n---\n\n# Counting Up, Down, and Stepping by N\n\nYou're not stuck with `i++`. The update is just an expression, so you can step by any amount in any direction.\n\nCounting down:\n\n\n```cpp\n#include \n\nint main() {\n for (int countdown = 5; countdown > 0; countdown--) {\n std::cout << countdown << \" items left in stock\" << std::endl;\n }\n return 0;\n}\n```\n\n\nThe condition uses `>` (greater than) rather than `<`, because the counter is moving down. When `countdown` hits `0`, the condition is false and the loop exits.\n\nStepping by two, useful for things like alternating rows in a table:\n\n\n```cpp\n#include \n\nint main() {\n for (int i = 0; i < 10; i += 2) {\n std::cout << \"Row \" << i << \" gets a discount banner\" << std::endl;\n }\n return 0;\n}\n```\n\n\nThe update `i += 2` jumps by two each iteration, so the loop runs five times instead of ten. The condition is still `i < 10`, so `i` never reaches or passes the limit.\n\nYou can step by any value, including non-integer values if the counter is a floating-point type. Floating-point counters are usually a bad idea (rounding error accumulates), but stepping by larger integers (5, 10, 100) shows up a lot in pagination, batching, or sampling every Nth row.\n\nA loyalty-points example that awards a bonus every fifth purchase in a sequence:\n\n\n```cpp\n#include \n\nint main() {\n int totalPurchases = 25;\n int bonus = 0;\n\n for (int i = 5; i <= totalPurchases; i += 5) {\n bonus += 50;\n std::cout << \"Bonus awarded at purchase \" << i\n << \" (running bonus: \" << bonus << \")\" << std::endl;\n }\n\n return 0;\n}\n```\n\n\nThe condition is `i <= totalPurchases`, with `<=` instead of `<`, because we want to include the 25th purchase. Switching `<` and `<=` is one of the most common sources of off-by-one bugs, which the next section addresses.\n\n---\n\n# Nested For Loops\n\nA `for` loop's body can contain another `for` loop. The inner loop runs to completion for every single iteration of the outer loop. This is how you walk a grid: rows on the outside, columns on the inside.\n\nA small multiplication table of product quantities:\n\n\n```cpp\n#include \n\nint main() {\n int rows = 3;\n int cols = 4;\n\n for (int r = 1; r <= rows; r++) {\n for (int c = 1; c <= cols; c++) {\n std::cout << (r * c) << \"\\t\";\n }\n std::cout << std::endl;\n }\n\n return 0;\n}\n```\n\n\nFor each value of `r` (1, 2, 3), the inner loop runs all four iterations of `c` (1, 2, 3, 4). The inner `std::cout` prints one cell. The outer `std::cout << std::endl` after the inner loop ends prints the line break that finishes the row.\n\nThe total number of times the inner body runs is `rows * cols`, which is `12` here. That multiplication is the thing to keep an eye on: a nested loop with two counters that each run to `n` does `n * n` work, which gets expensive fast.\n\n\n> **INFO**\n>\n> **Cost:** Two nested loops over `n` items do `n * n` (O(n^2)) work in total. For `n = 1000`, that's a million iterations. For `n = 100,000`, it's ten billion, which will take minutes or hours. Always know the size of your inputs before writing nested loops over them.\n\n\nA more application-flavored example: applying a discount to every item in every order.\n\n\n```cpp\n#include \n#include \n\nint main() {\n std::vector> orders = {\n {19.99, 4.49},\n {12.00, 7.50, 3.25},\n {89.99}\n };\n\n double discountRate = 0.10;\n\n for (int orderIndex = 0; orderIndex < static_cast(orders.size()); orderIndex++) {\n double orderTotal = 0.0;\n for (int itemIndex = 0; itemIndex < static_cast(orders[orderIndex].size()); itemIndex++) {\n double discounted = orders[orderIndex][itemIndex] * (1.0 - discountRate);\n orderTotal += discounted;\n }\n std::cout << \"Order \" << (orderIndex + 1)\n << \" total after discount: $\" << orderTotal << std::endl;\n }\n\n return 0;\n}\n```\n\n\nThe outer loop walks orders. The inner loop walks items in the current order. `orderTotal` is declared inside the outer loop, so it resets to `0.0` at the start of each order, which is exactly what we want. If we'd declared it before the outer loop, every order would have inherited the previous order's total.\n\nThat reset is one of the subtleties of nested loops: the inner loop's counter resets each time it starts (it's a fresh variable each iteration of the outer loop), and any variable declared inside the outer body also resets. Variables declared outside the loops persist, which is sometimes what you want and sometimes a bug. Pay attention to where you declare things.\n\n---\n\n# Off-by-One Errors\n\nThe single most common bug in `for` loops is going one iteration too many or one too few. It's so common that it has a name: an **off-by-one error**, sometimes called a fencepost error.\n\nThe two usual flavors:\n\n\n```cpp\ndouble prices[] = {9.99, 14.50, 3.25, 22.00};\n\n// Buggy: condition uses <= with size, runs i = 0, 1, 2, 3, 4 (one too many)\nfor (int i = 0; i <= 4; i++) {\n std::cout << prices[i] << std::endl; // prices[4] is out of bounds\n}\n```\n\n\nThe array has four elements, with valid indices `0` through `3`. The loop runs five times, ending at `i = 4`, and `prices[4]` reads memory past the end of the array. That's undefined behavior: the program might print a garbage value, crash, or appear to work fine and corrupt something else later. There's no friendly error message.\n\nThe fix is to use `<` instead of `<=`, or use the array's size directly:\n\n\n```cpp\ndouble prices[] = {9.99, 14.50, 3.25, 22.00};\nint n = 4;\n\nfor (int i = 0; i < n; i++) {\n std::cout << prices[i] << std::endl; // safe: i goes 0, 1, 2, 3\n}\n```\n\n\nThe rule of thumb: when iterating from `0`, use `i < size`, not `i <= size`. When iterating from `1` and the upper bound is inclusive, use `i <= upperBound`. Mixing the two is where bugs come from.\n\nThe other flavor of off-by-one is starting at the wrong value:\n\n\n```cpp\n// Buggy: starts at 1, skips the first element at index 0\nfor (int i = 1; i < 4; i++) {\n std::cout << prices[i] << std::endl;\n}\n```\n\n\nArray indices in C++ start at `0`. If the loop starts at `1`, the element at index `0` is silently skipped. The compiler won't help: the loop is valid C++, it just walks the wrong elements.\n\nA useful habit: before running a loop, mentally trace the first iteration and the last iteration. If you can name the exact value of `i` for both, off-by-one errors get rare.\n\n---\n\n# Modifying the Loop Variable Inside the Body\n\nThe counter is a regular variable, so you can write to it from inside the body. That's almost always a mistake, even when it looks like a clever shortcut.\n\n\n```cpp\n// Confusing: who's in charge of i?\nfor (int i = 0; i < 10; i++) {\n std::cout << i << std::endl;\n if (i == 3) {\n i = 7; // jump past the next four iterations\n }\n}\n```\n\n\nThis prints `0 1 2 3 8 9`, because at `i = 3` the body bumps `i` to `7`, then the header runs `i++`, making `i = 8`, and the loop continues. A reader has to step through the loop carefully to figure that out.\n\nIf you genuinely need to skip ahead, use a `while` loop where the control is explicit, or restructure the logic with `continue`. Reaching into a `for` loop's counter from the body breaks the contract a reader expects: that the header decides how the counter moves.\n\nThere's one exception. If the body removes elements from a `std::vector` while iterating by index, the index needs to be adjusted. Even there, most code uses iterators or `std::remove_if` and avoids the index-fiddling entirely.\n\n---\n\n# Signed vs Unsigned: The size_t Trap\n\nContainer sizes in C++ (`std::vector::size()`, `std::string::size()`, `std::array::size()`) return `std::size_t`, which is an **unsigned** integer type. Loop counters are usually `int`, which is **signed**. Comparing the two with `<` or `<=` triggers a compiler warning and, in rare cases, a bug.\n\n\n```cpp\n#include \n#include \n\nint main() {\n std::vector prices = {9.99, 14.50, 3.25};\n\n // g++ warns: comparison of integer expressions of different signedness\n for (int i = 0; i < prices.size(); i++) {\n std::cout << prices[i] << std::endl;\n }\n\n return 0;\n}\n```\n\n\nWith `g++ -Wall`, that loop produces:\n\n\n```shell\nwarning: comparison of integer expressions of different signedness:\n'int' and 'std::vector::size_type' {aka 'long unsigned int'}\n```\n\n\nThe warning is correct. `prices.size()` is `std::size_t`. When you compare `int` to `std::size_t`, the `int` is promoted to `std::size_t`. If `i` ever held a negative value (it doesn't in this loop, but the compiler can't tell), the promotion would turn `-1` into a huge positive number and the comparison would lie.\n\nThree reasonable fixes:\n\n\n```cpp\n// Option 1: cast the size to int. Cheap and obvious, but undefined if size > INT_MAX.\nfor (int i = 0; i < static_cast(prices.size()); i++) { /* ... */ }\n\n// Option 2: use the same type as size(). No warning, no surprise.\nfor (std::size_t i = 0; i < prices.size(); i++) { /* ... */ }\n\n// Option 3: range-based for. Best when you don't actually need the index.\nfor (double price : prices) { /* ... */ }\n```\n\n\nThe range-based `for` is the cleanest answer when you don't need the index. When you do need the index, prefer `std::size_t` over `int`, and the warning goes away. Casting works too but always feels like papering over the issue.\n\n---\n\n# When to Pick For Over While\n\nA `for` loop and a `while` loop can do the same things. The choice is about which one matches the shape of your problem more clearly.\n\n\n| Use a `for` loop when... | Use a `while` loop when... |\n|---|---|\n| The number of iterations is known up front | The loop runs \"until something happens\" |\n| You're walking an index from one value to another | The condition depends on external state, like user input |\n| The counter has a fixed start, end, and step | There's no natural counter |\n| All the loop bookkeeping fits in the header | The body decides when to exit |\n\n\nA clean way to remember it: if you can answer \"how many times?\" before the loop starts, prefer `for`. If the answer is \"I don't know, keep going until X happens,\" prefer `while`.\n\nTwo examples of the same task, written both ways:\n\n\n```cpp\n// for: walking an array, count is known\ndouble prices[] = {9.99, 14.50, 3.25, 22.00};\nfor (int i = 0; i < 4; i++) {\n std::cout << prices[i] << std::endl;\n}\n\n// while: reading input until \"quit\"\nstd::string command;\nwhile (command != \"quit\") {\n std::cin >> command;\n}\n```\n\n\nBoth are legal C++. The `for` reads cleanly because the start, end, and step are all visible at the top of the loop. The `while` reads cleanly because there's no counter, only a condition. Forcing either pattern into the other shape produces awkward code.\n\nFor arrays and `std::vector`, the range-based `for` is often a better fit when you don't need the index, because it can't go out of bounds.\n\n---\n\n# Receipt Example: Putting It Together\n\nA small program that uses several of the patterns above to print a receipt with subtotals, a discount, and a final total. It's longer than the snippets so far, but every line uses something from this lesson.\n\n\n```cpp\n#include \n#include \n\nint main() {\n std::string items[] = {\"Wireless Mouse\", \"USB Cable\", \"Notebook\", \"Pen Set\"};\n double prices[] = {24.99, 8.50, 12.00, 6.75};\n int quantities[] = {1, 2, 3, 4};\n int itemCount = 4;\n\n double subtotal = 0.0;\n\n std::cout << std::fixed << std::setprecision(2);\n std::cout << \"Item Qty Price Line Total\" << std::endl;\n\n for (int i = 0; i < itemCount; i++) {\n double lineTotal = prices[i] * quantities[i];\n subtotal += lineTotal;\n std::cout << std::left << std::setw(20) << items[i]\n << std::setw(7) << quantities[i]\n << std::setw(9) << prices[i]\n << lineTotal << std::endl;\n }\n\n double discountRate = (subtotal > 50.0) ? 0.10 : 0.0;\n double discount = subtotal * discountRate;\n double finalTotal = subtotal - discount;\n\n std::cout << \"Subtotal: $\" << subtotal << std::endl;\n std::cout << \"Discount: $\" << discount << std::endl;\n std::cout << \"Total: $\" << finalTotal << std::endl;\n\n return 0;\n}\n```\n\n\nThe `for` loop does three things in one pass: it computes each line total, adds it to the running subtotal, and prints the receipt row. After the loop, the subtotal is used to compute a tiered discount (10% if the subtotal is over $50, nothing otherwise), and the discount is subtracted from the subtotal to get the final total.\n\nThe whole pattern (walk a list, accumulate a value, do something with the total after the loop) is one of the most common shapes `for` shows up in.\n\n---\n\n# Summary\n\n- A `for` loop has three header pieces (init, condition, update) separated by semicolons. Init runs once, condition runs before every iteration, body and update each run once per iteration.\n- The body might run zero times if the condition is false on the first check.\n- A variable declared in the init part is local to the loop and goes out of scope at the closing brace.\n- All three header parts are optional. `for (;;)` is an infinite loop that relies on `break` or `return` to exit.\n- The comma operator lets you put multiple init expressions or multiple update expressions in one header. The most common use is two indices walking toward each other.\n- You can count up, count down, or step by any amount. The update can be `i++`, `i--`, `i += 2`, or any expression that changes the counter.\n- Nested `for` loops run the inner loop fully on every iteration of the outer loop. Total work is the product of the two iteration counts, which grows fast.\n- Off-by-one errors are the most common loop bug. Mentally trace the first and last iteration, and prefer `i < size` over `i <= size` when starting at `0`.\n- Comparing a signed loop counter to `std::size_t` from `size()` triggers a warning. Use `std::size_t` for the counter, or switch to a range-based `for` when you don't need the index.\n- Pick `for` when the iteration count is known up front; pick `while` when the loop runs until something external happens.\n\nIn the next lesson, we'll look at the `while` loop, the form that fits the \"keep going until X\" shape: no counter, just a condition checked at the top of every iteration.","pageType":"cpp"}

For Loop

Get Premium