{"title":"Range-Based For Loop","description":null,"content":"Walking through every item in a container is one of the most common operations any program performs: print every product in a catalog, sum the prices in a cart, mark every order as shipped. The classic `for` loop works for this, but it is noisy because half the line manages an index variable that the body never uses directly. The range-based for loop, added in C++11, removes that noise. Name the container, name each element, and the loop handles the rest.\n\n---\n\n# The Basic Syntax\n\nA range-based for loop has this shape:\n\n\n```cpp\nfor (declaration : range) {\n // body, runs once per element\n}\n```\n\n\n`declaration` is the name (and type) for each element inside the body. `range` is the container being iterated over. On each pass, the loop pulls the next element out of the container and binds it to the declared name.\n\nA small, useful version sums the prices in a shopping cart:\n\n\n```cpp\n#include \n#include \n\nint main() {\n std::vector cartPrices = {29.99, 14.99, 9.99, 49.99, 19.99};\n\n double total = 0.0;\n for (double price : cartPrices) {\n total += price;\n }\n\n std::cout << \"Cart total: $\" << total << std::endl;\n return 0;\n}\n```\n\n\nRead it almost like an English sentence: \"for each `price` in `cartPrices`, add it to the total.\" No index, no `size()` call, no risk of writing `<= size()` instead of `< size()` and walking off the end.\n\nThe loop runs once for every element, in the order the container stores them. For a `std::vector`, that is first to last. When the loop runs out of elements, control falls through to the line after the closing brace.\n\n---\n\n# What Can Go on the Right Side\n\nThe expression to the right of the colon does not have to be a `std::vector`. The range-based for loop works on anything that exposes its elements through a pair of `begin()` and `end()` functions. That covers nearly every standard container:\n\n- C-style arrays: `int sizes[] = {7, 9, 11};`\n- `std::vector` (resizable, the default choice for sequences)\n- `std::array` (fixed size, lives on the stack)\n- `std::string` (treated as a sequence of `char`)\n- `std::map`, `std::unordered_map`, `std::set`, `std::list`, `std::deque`\n- A braced-init list written directly in the loop, like `{1, 2, 3}`\n\nA short example of each:\n\n\n```cpp\n#include \n#include \n#include \n#include \n\nint main() {\n // C-style array\n int stockLevels[] = {12, 7, 3, 20, 5};\n for (int count : stockLevels) {\n std::cout << count << \" \";\n }\n std::cout << std::endl;\n\n // std::array\n std::array topPrices = {99.99, 79.99, 49.99};\n for (double price : topPrices) {\n std::cout << \"$\" << price << \" \";\n }\n std::cout << std::endl;\n\n // std::string\n std::string productCode = \"SKU42\";\n for (char ch : productCode) {\n std::cout << ch << \".\";\n }\n std::cout << std::endl;\n\n // Inline braced-init list\n for (int rating : {5, 4, 5, 3, 5}) {\n std::cout << rating << \" \";\n }\n std::cout << std::endl;\n\n return 0;\n}\n```\n\n\nThe last form is easy to overlook. A `{ ... }` list can appear directly in the loop header, iterating over its elements without a named container. It is useful for short, fixed sets of values, such as trying a handful of test cases.\n\nC-style arrays work in a range-based for only when their size is known at compile time. If the array has decayed to a pointer (for example, after being passed into a function as `int arr[]`), the loop has no element count to walk and the code will not compile. Use `std::vector` or `std::array` when passing containers around.\n\n---\n\n# The Three Modes: Value, Reference, Const Reference\n\nThe most important choice when writing a range-based for loop is what appears on the left side of the colon. Three patterns are common, and they behave differently.\n\n### Mode 1: By Value (Copy Each Element)\n\n\n```cpp\nfor (auto price : cartPrices) {\n // price is a fresh copy of each element\n}\n```\n\n\nOn each pass, the loop **copies** the current element into the local variable `price`. That is fine and cheap when the elements are small built-in types like `int`, `double`, or `char`. It is not fine when the elements are heavy types like `std::string`, big classes, or vectors-of-things, because every iteration pays the cost of constructing and destroying a copy.\n\n`for (auto name : customerNames)` where `customerNames` is a `std::vector` copies every string on every iteration. For a list of ten thousand customers, that is ten thousand unnecessary allocations. Use `const auto& name` instead.\n\nBy-value is also the right choice when a local copy is needed that can be mutated without affecting the original container, but that case is rare.\n\n### Mode 2: By Reference (Read and Modify in Place)\n\n\n```cpp\nfor (auto& price : cartPrices) {\n price *= 0.9; // apply a 10% discount to every product\n}\n```\n\n\nThe `&` turns the loop variable into a **reference** to the container's element. No copy is made. Whatever is assigned to `price` writes through to the actual element in the vector. This is the mode for changing every element, such as applying a discount, marking every order as shipped, or zeroing out a row of counters.\n\nThe full version:\n\n\n```cpp\n#include \n#include \n\nint main() {\n std::vector cartPrices = {29.99, 14.99, 9.99, 49.99, 19.99};\n\n // Apply a 10% discount to every product in the cart\n for (auto& price : cartPrices) {\n price *= 0.9;\n }\n\n for (double price : cartPrices) {\n std::cout << \"$\" << price << \" \";\n }\n std::cout << std::endl;\n\n return 0;\n}\n```\n\n\nThe first loop modifies the vector in place. The second loop, which uses by-value, reads each element to print it. Two loops, two modes, each picked for its job.\n\n### Mode 3: By Const Reference (Read-Only, No Copy)\n\n\n```cpp\nfor (const auto& price : cartPrices) {\n total += price; // read but never modify\n}\n```\n\n\nThe `const auto&` form is a read-only reference. No copy is made (so it is cheap, even for `std::string` or large objects), and the element cannot be written to by accident (so the compiler catches bugs where a read was intended but a write was typed). For non-trivial element types, this is the safe default.\n\nA simple rule: when the element is not being modified and is not a small built-in like `int` or `double`, use `const auto&` first. If later modification is needed, drop the `const`. If the type is tiny, switch to a plain `auto` copy.\n\n### Picking the Right Mode\n\nThe rough rule in table form:\n\n\n| Goal | Element type | Use |\n|---|---|---|\n| Read, do not modify | Small (int, double, char, bool) | `for (auto x : items)` |\n| Read, do not modify | Anything else (string, class, vector) | `for (const auto& x : items)` |\n| Modify the element | Any type | `for (auto& x : items)` |\n| Get a fresh local copy to mutate | Any type | `for (auto x : items)` |\n\n\nThe middle row is where the biggest performance wins hide. Forgetting `&` on a loop over a vector of strings is a common preventable performance bug in modern C++ code.\n\n\n```mermaid\nflowchart LR\n A[for x : items]:::cyan --> B{Modify
elements?}:::orange\n B -->|Yes| C[auto&
reference]:::green\n B -->|No| D{Element
cheap to copy?}:::orange\n D -->|Yes, like int| E[auto
by value]:::teal\n D -->|No, like string| F[const auto&
const reference]:::green\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```\n\n\nThe flow above is the decision tree to run through when writing a range-based for.\n\n---\n\n# Memory: Copy vs Reference, Side by Side\n\nIt helps to see what happens in memory when one mode is picked over another. Suppose `cartPrices` is `{29.99, 14.99, 9.99}` on the second pass of the loop.\n\n\n```mermaid\nflowchart LR\n subgraph V[Vector in memory]\n V0[29.99]:::cyan\n V1[14.99]:::cyan\n V2[9.99]:::cyan\n end\n\n subgraph BV[By value: auto price]\n P1[price = 14.99
fresh copy]:::orange\n end\n\n subgraph BR[By reference: auto and amp price]\n P2[price points to
vector slot 1]:::green\n end\n\n V1 -.->|copied| P1\n V1 ===|aliases| P2\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n```\n\n\nThe vector lives once in memory. When the loop uses `auto`, a fresh copy of slot 1 is made into `price` for that iteration, used, then destroyed at the end of the iteration. When the loop uses `auto&`, no copy is made; `price` is another name for the slot. Writing through that name writes the original element.\n\nFor an element type like `double`, the copy on the left side is one register's worth of data, so the difference is negligible. For an element type like `std::string` that owns heap memory, the copy version allocates a fresh buffer for every iteration. That is where the performance gap appears.\n\n---\n\n# Iterating Over a `std::map`\n\nMaps are slightly different. A `std::map` stores pairs, and each \"element\" the loop sees is a `std::pair`. The old-style way to read those pairs was clunky:\n\n\n```cpp\nfor (const auto& entry : prices) {\n std::cout << entry.first << \": \" << entry.second << std::endl;\n}\n```\n\n\n`entry.first` is the key, `entry.second` is the value. It works, but the names are unhelpful. Since C++17, structured bindings let you name the two pieces directly:\n\n\n```cpp\n#include \n#include \n#include \n\nint main() {\n std::map prices = {\n {\"Wireless Mouse\", 24.99},\n {\"USB Cable\", 9.99},\n {\"Notebook\", 14.99}\n };\n\n for (const auto& [product, price] : prices) {\n std::cout << product << \": $\" << price << std::endl;\n }\n\n return 0;\n}\n```\n\n\nThe `[product, price]` syntax is a **structured binding**: it pulls the two fields of the pair into named local variables. The names can be anything; `product` and `price` happen to be descriptive here. Compile this with `-std=c++17` or later.\n\nNote the output order. `std::map` keeps its keys sorted, so the loop visits them in alphabetical order, not the order they were inserted. For insertion order, use `std::unordered_map` paired with a separate vector of keys, or a different container entirely. The STL section covers that trade-off in detail.\n\nTo modify the values (but not the keys, which are always const inside a map), drop the `const`:\n\n\n```cpp\nfor (auto& [product, price] : prices) {\n price *= 0.9; // 10% off everything\n}\n```\n\n\nThe `price` reference writes back into the map. The `product` binding is still const because map keys cannot be mutated through iteration; mutating a key would corrupt the map's internal ordering.\n\n---\n\n# The Init-Statement Form (C++20)\n\nC++20 added one more variant. A single setup statement can run before the loop, in the loop header itself:\n\n\n```cpp\nfor (auto items = getCart(); const auto& item : items) {\n // use item\n}\n```\n\n\nThe first piece, `auto items = getCart();`, runs once before the loop starts. Its scope is the loop. The second piece is the regular range-based for. This is useful when the range comes from a function that returns by value, because it pins the result to a named variable inside the loop's scope.\n\nA short example:\n\n\n```cpp\n#include \n#include \n#include \n\nstd::vector getCart() {\n return {\"Mouse\", \"Keyboard\", \"Monitor\"};\n}\n\nint main() {\n for (auto items = getCart(); const auto& item : items) {\n std::cout << \"- \" << item << std::endl;\n }\n return 0;\n}\n```\n\n\nWithout the init-statement form, `auto items = getCart();` goes on one line and the for loop on the next. With it, both fit on a single line and `items` is scoped tightly to the loop. Compile this with `-std=c++20`.\n\nThis is a niche feature. Most range-based for loops will not need it. It exists for the case where a temporary should be kept alive only for the loop.\n\n---\n\n# What You Lose: No Index\n\nThe range-based for loop hides the index. That is the point. But sometimes the index is needed, for example to print \"Item 1: Mouse\", \"Item 2: Keyboard\", and so on. Two clean ways recover it.\n\n### Option 1: A Manual Counter\n\nKeep a separate integer that is incremented each iteration:\n\n\n```cpp\n#include \n#include \n#include \n\nint main() {\n std::vector orderList = {\"Mouse\", \"Keyboard\", \"Monitor\"};\n\n int orderNumber = 1;\n for (const auto& product : orderList) {\n std::cout << \"Order \" << orderNumber << \": \" << product << std::endl;\n orderNumber++;\n }\n return 0;\n}\n```\n\n\nThis works, but it is a small step backward toward the noise that range-based for was meant to remove. It is fine when the counter is incidental to the loop.\n\n### Option 2: Go Back to a Classic For\n\nWhen the index is the point, the classic indexed for loop is clearer:\n\n\n```cpp\nfor (std::size_t i = 0; i < orderList.size(); ++i) {\n std::cout << \"Order \" << (i + 1) << \": \" << orderList[i] << std::endl;\n}\n```\n\n\nThe rule of thumb: when only the elements matter, use range-based for. When positions matter (skipping every other one, accessing two elements at once, walking backward), use a classic for.\n\n---\n\n# Don't Resize the Container Mid-Loop\n\nOne rule matters: do not change the size of the container while iterating over it. Adding elements with `push_back` may reallocate the vector's internal buffer, leaving the loop's invisible iterator pointing at freed memory. Erasing elements shifts what is behind them, so the loop skips or revisits items it should not.\n\n\n```cpp\nstd::vector stockLevels = {5, 0, 12, 0, 7};\nfor (auto& level : stockLevels) {\n if (level == 0) {\n // Don't do this. Erasing during a range-based for is undefined behavior.\n // stockLevels.erase(it);\n }\n}\n```\n\n\nThis is called **iterator invalidation**, one of the classic C++ landmines. The fix depends on the operation:\n\n- To remove elements during iteration, use the erase-remove idiom or `std::erase_if` (C++20). The STL section covers both.\n- To add elements during iteration, finish the loop first and apply the changes after, or build a new container during the loop.\n- To modify existing elements in place, range-based for with `auto&` is fine; modification does not change the container's size, only its contents.\n\nThe short version: read-and-modify is safe. Resize-while-iterating is not.\n\n---\n\n# A Larger Example: Processing Orders\n\nThe following program uses three different modes of range-based for in three places, on a single list of orders. It is a worked example of when to pick which mode.\n\n\n```cpp\n#include \n#include \n#include \n\nstruct Order {\n std::string customer;\n double amount;\n bool shipped;\n};\n\nint main() {\n std::vector orders = {\n {\"Priya\", 74.97, false},\n {\"Sam\", 149.50, false},\n {\"Lena\", 29.99, false}\n };\n\n // 1. Read-only pass: print every order. Use const auto& to avoid copying.\n std::cout << \"Pending orders:\" << std::endl;\n for (const auto& order : orders) {\n std::cout << \" \" << order.customer << \" owes $\" << order.amount << std::endl;\n }\n\n // 2. Mutating pass: apply a 5% loyalty discount and mark every order shipped.\n for (auto& order : orders) {\n order.amount *= 0.95;\n order.shipped = true;\n }\n\n // 3. Summing pass: total revenue. Local copy of a double is cheap.\n double revenue = 0.0;\n for (auto order : orders) {\n revenue += order.amount;\n }\n\n std::cout << \"Total revenue after discount: $\" << revenue << std::endl;\n return 0;\n}\n```\n\n\nThree loops, three modes. The first one reads. The second one mutates. The third one needs the `amount` field but does not need to modify the order, so a by-value copy works (and is slightly clearer than reaching into a reference). Each choice matches what the loop does.\n\nThe by-value loop in step 3 is not strictly cheap: it copies the whole `Order` struct including the customer's name. For a struct this small it is fine, but for a heavier type, `const auto& order` and then `revenue += order.amount` would be better. Picking the right mode is partly habit, partly thinking about the size of the element type.\n\n---\n\n# When to Use Range-Based For\n\nThe range-based for loop is the default for any traversal. Before writing a classic indexed for loop, ask: is the index actually needed? If not, the range-based form is shorter and harder to get wrong.\n\nA classic for is still the right choice in narrow cases:\n\n- The index itself is needed (numbered output, even/odd selection).\n- Iterating over two containers in lockstep (the parallel-index pattern).\n- Walking backward, skipping elements, or stepping by more than one.\n- Resizing the container during the walk.\n\nEverything else is range-based for territory.","pageType":"cpp"}

Range-Based For Loop

Get Premium