Modern C++ · Lesson 51

Range-Based Loops

For years, looping over an array meant counting positions: start at 0, stop before the size, add 1 each time. It works, but it is a lot of bookkeeping for a simple job. C++11 gave us a shorter, safer way: the range-based for loop. You just say "for each item in this collection, do this" — and the loop handles all the counting for you.

1. What is a range-based for loop?

A range-based for loop visits every element of a container — an array, a vector, a string, a map — one by one, from first to last. You do not write an index, you do not write a stop condition, and you cannot run past the end by mistake. The loop knows exactly where the container ends.

Think of a teacher calling the roll: instead of saying "student number 1, student number 2, student number 3", she simply walks down the class list and names each student in turn. That is exactly what this loop does with your data — it takes each element in turn and hands it to you.

2. The basic syntax

The syntax is short: for (auto item : collection). The auto lets the compiler work out the element type, and the colon reads as "in". So for (auto score : scores) means "for each score in scores".

Code story: A teacher has four test scores stored in a vector. She wants to print every score on one line. The old way needs an index and the size of the vector; the new way just says "for each score in scores, print it". Watch how the loop visits 85, then 92, then 78, then 95 — in order, with no counting code at all.

#include <iostream>
#include <vector>
using namespace std;

int main() {
    vector<int> scores = {85, 92, 78, 95};
    for (auto score : scores) {
        cout << score << " ";
    }
    cout << endl;
    return 0;
}

85 92 78 95

What just happened? The loop ran four times — once per element. Each time, score held a copy of the next element, and we printed it. There is no index variable, no .size() call, and no chance of reading past the end of the vector.

Here is the same idea side by side with the old loop, so you can see how much simpler the new one is:

3. Changing elements with auto&

Plain auto x gives you a copy of each element. Changing the copy changes nothing in the container — the original stays exactly as it was. If you want to change the real elements, use a reference: write auto& x. The & turns the loop variable into a nickname for the real element, so anything you do to it happens to the container itself.

Code story: A shop wants to double every price in its list for a sale. First the program prints the old prices, then it loops with auto& and doubles each real price, then it prints the list again. Watch the second printout: every price is doubled, because the loop touched the real elements, not copies.

#include <iostream>
#include <vector>
using namespace std;

int main() {
    vector<int> prices = {10, 20, 30};
    cout << "Before: ";
    for (auto price : prices) {
        cout << price << " ";
    }
    cout << endl;
    for (auto& price : prices) {
        price = price * 2;
    }
    cout << "After: ";
    for (auto price : prices) {
        cout << price << " ";
    }
    cout << endl;
    return 0;
}

Before: 10 20 30
After: 20 40 60

What just happened? The first loop only printed the prices. The second loop used auto&, so price was the real element each time — doubling it doubled the value stored in the vector. The third loop printed the changed list to prove it.

Code story: Now watch what happens when the same job is tried with plain auto instead of auto&. The loop doubles each copy and throws it away — the prices in the vector never change. The final printout proves it: the list is exactly the same as before.

#include <iostream>
#include <vector>
using namespace std;

int main() {
    vector<int> prices = {10, 20, 30};
    for (auto price : prices) {
        price = price * 2;   // changes only the copy
    }
    cout << "After trying with auto: ";
    for (auto price : prices) {
        cout << price << " ";
    }
    cout << endl;
    return 0;
}

After trying with auto: 10 20 30

What just happened? With plain auto, each price is a separate copy. Doubling the copy does nothing to the vector, so the printout shows the original prices 10, 20 and 30. This is the most common beginner mistake with range-based loops — and now you know how to spot it.

Rule of thumb: Use const auto& when you only read, auto& when you must change, and plain auto only for tiny values like int or double.

4. Reading safely with const auto&

When you only need to read the elements — especially big ones like strings — the best choice is const auto&. The & means no copy is made, and the const means you promise not to change anything. You get the speed of a reference with the safety of a read-only view. If you try to change the element by accident, the compiler stops you at once.

Code story: Three friends' names are stored in a vector of strings. Copying a string costs time and memory, so the program reads each name through a const reference instead. Watch: the names print exactly as stored, and not a single copy was made.

#include <iostream>
#include <vector>
#include <string>
using namespace std;

int main() {
    vector<string> names = {"Asha", "Ravi", "Maya"};
    for (const auto& name : names) {
        cout << name << " ";
    }
    cout << endl;
    return 0;
}

Asha Ravi Maya

What just happened? Each name is a read-only view of the real string in the vector — no copying, no changing. This is the form professional C++ code uses most often, because it is fast and safe at the same time.

5. Looping over a string

A string is also a container — a container of characters. A range-based loop over a string visits every character, one by one. That makes small jobs like counting letters, checking spelling, or cleaning up text very easy.

Code story: A teacher wants to count the vowels in the word "education". The loop looks at each letter in turn and asks: is this letter a, e, i, o or u? Each time the answer is yes, the counter goes up by one. Watch the counter reach 5 — the five vowels e, u, a, i and o.

#include <iostream>
#include <string>
using namespace std;

int main() {
    string word = "education";
    int vowels = 0;
    for (char letter : word) {
        if (letter == 'a' || letter == 'e' || letter == 'i' || letter == 'o' || letter == 'u') {
            vowels++;
        }
    }
    cout << "Vowels in " << word << ": " << vowels << endl;
    return 0;
}

Vowels in education: 5

What just happened? The loop visited all nine letters of "education". Five of them — e, u, a, i and o — are vowels, so the counter ended at 5. Notice the loop variable here is a plain char: a single character is tiny, so copying it costs nothing.

6. Looping over a map

Maps store pairs: a key and a value. When you loop over a map, each element is a pair. The key sits in .first and the value sits in .second. With const auto& you can read every pair without copying a single one.

Code story: A school register maps roll numbers to student names. The program loops over the map and prints each roll number with its name. Watch how the loop hands us one pair at a time, and how the pairs arrive already sorted by roll number — that is the map doing its job.

#include <iostream>
#include <map>
#include <string>
using namespace std;

int main() {
    map<int, string> students = {{101, "Asha"}, {102, "Ravi"}, {103, "Maya"}};
    for (const auto& student : students) {
        cout << student.first << ": " << student.second << endl;
    }
    return 0;
}

101: Asha
102: Ravi
103: Maya

What just happened? The loop ran once per entry in the map. Each student is a pair: .first is the roll number (the key) and .second is the name (the value). Because a map keeps its keys sorted, the output comes out in roll-number order: 101, 102, 103.

In C++17 and later you can unpack the pair right in the loop: for (const auto& [roll, name] : students) gives you two tidy variables, roll and name, instead of .first and .second. This is called a structured binding, and it is the modern way to loop over maps.

7. Which loop variable should you use?

The four forms look alike, but they behave very differently. Here is the whole choice on one table — when in doubt, reach for const auto&:

8. Common mistakes

Range-based loops are simple, but five mistakes catch almost every beginner. Learn them now and you will never waste an afternoon on them:

9. Mini program: the shopping cart total

Time to put it all together. Our final program is a small shopping cart: a vector of prices, one range-based loop to add them up, and a tidy summary at the end.

Code story: A customer has four items in the cart, priced 12.50, 40.00, 23.00 and 100.00. The program starts the total at zero, then loops over the prices and adds each one to the total. At the end it prints how many items there are and what the customer must pay. Watch the total grow: 12.5, then 52.5, then 75.5, then 175.5.

#include <iostream>
#include <vector>
using namespace std;

int main() {
    vector<double> prices = {12.5, 40.0, 23.0, 100.0};
    double total = 0;
    for (auto price : prices) {
        total += price;
    }
    cout << "Items: " << prices.size() << endl;
    cout << "Total: " << total << endl;
    return 0;
}

Items: 4
Total: 175.5

What just happened? The loop added each price to total in turn: 12.5, then 52.5, then 75.5, then 175.5. The whole program is seven lines of real logic — no index, no size check, no room for an off-by-one error. That is the range-based loop doing what it does best: letting you think about the job, not the counting.