range-based for loop

Angol

Főnév

range-based for loop (tsz. range-based for loops)

1. (informatika) A tartomány alapú for ciklus (range-based for loop) egy egyszerűsített és olvashatóbb formája a hagyományos for ciklusnak C++-ban. Elsősorban tömbök és konténerek (pl. vector, array, map, set) elemeinek bejárására használjuk. Az iterációt automatikusan kezeli, így nem kell külön változót inicializálni és indexeket kezelni.

---

1. Tartomány alapú for ciklus szintaxisa

for (adatTípus változó : kollekció) {
    // Ciklus törzse
}

Működés lépésről lépésre:

1. A ciklus végigmegy a kollekció minden elemén.
2. Az aktuális elem értéke a cikluson belüli változóba kerül.
3. A törzsben az aktuális elem felhasználható.
4. Az iteráció automatikusan folytatódik, amíg az összes elem feldolgozásra nem kerül.

---

2. Egyszerű példa – Tömb bejárása

#include <iostream>

int main() {
    int tomb[] = {10, 20, 30, 40, 50};

    for (int szam : tomb) {
        std::cout << szam << " ";
    }
    return 0;
}

Kimenet:

10 20 30 40 50

• A for ciklus automatikusan végigmegy a tomb tömb minden elemén, és az aktuális értéket szam változóba helyezi.
• Az std::cout << szam kiírja az értékeket szóközzel elválasztva.

---

3. Tartomány alapú for ciklus vektorral

A std::vector dinamikus méretű konténer, amelyet gyakran használunk C++-ban.

Példa: Vektor bejárása

#include <iostream>
#include <vector>

int main() {
    std::vector<int> szamok = {5, 10, 15, 20, 25};

    for (int szam : szamok) {
        std::cout << szam << " ";
    }
    return 0;
}

Kimenet:

5 10 15 20 25

• Az std::vector<int> egy dinamikus tömb, amelyet a ciklus ugyanúgy bejár, mint a hagyományos tömböt.
• A for (int szam : szamok) ciklus végigmegy a szamok vektor minden elemén.

---

4. Referencia használata – Hatékonyabb memóriahasználat

Ha az elemek másolása helyett referencia szerint szeretnénk dolgozni, használjuk az & operátort:

#include <iostream>
#include <vector>

int main() {
    std::vector<int> szamok = {1, 2, 3, 4, 5};

    for (int& szam : szamok) {
        szam *= 2;  // Minden elem értékét megduplázzuk
    }

    for (int szam : szamok) {
        std::cout << szam << " ";
    }
    return 0;
}

Kimenet:

2 4 6 8 10

Miért fontos a referencia (&)?

• Ha referencia nélkül használjuk (int szam : szamok), akkor a for ciklus minden egyes elemet másolatként ad át a szam változónak.
• Ha int& szam : szamok formát használunk, akkor közvetlenül az eredeti elemeket módosítjuk.
• Referenciák használata különösen fontos nagy méretű adatszerkezetek esetén.

---

5. const referencia – Ha nem akarjuk módosítani az adatokat

Ha biztosak akarunk lenni abban, hogy a ciklus nem módosítja az eredeti adatokat, használhatjuk a const kulcsszót:

#include <iostream>
#include <vector>

int main() {
    std::vector<std::string> nevek = {"Anna", "Béla", "Cecília"};

    for (const std::string& nev : nevek) {
        std::cout << nev << " ";
    }
    return 0;
}

Kimenet:

Anna Béla Cecília

• A const std::string& nev megakadályozza az elemek módosítását, miközben elkerüli a felesleges másolásokat.

---

6. Tartomány alapú for ciklus std::map-pel (asszociatív tömb)

Az std::map kulcs-érték párokat tárol, és a tartomány alapú for ciklus segítségével könnyedén bejárható.

#include <iostream>
#include <map>

int main() {
    std::map<std::string, int> diakok = {{"Anna", 95}, {"Béla", 88}, {"Cecília", 78}};

    for (const auto& par : diakok) {
        std::cout << par.first << " pontszáma: " << par.second << std::endl;
    }
    return 0;
}

Kimenet:

Anna pontszáma: 95
Béla pontszáma: 88
Cecília pontszáma: 78

• par.first → a kulcs (pl. név)
• par.second → az érték (pl. pontszám)
• Az auto& használata megkönnyíti az iterációt, mert az std::map<std::string, int>::value_type típus hosszan írható lenne.

---

7. C++17 structured bindings a map bejárására

C++17 óta struktúrált kötésekkel (structured bindings) közvetlenül két változóba bonthatjuk a kulcs-érték párokat:

#include <iostream>
#include <map>

int main() {
    std::map<std::string, int> diakok = {{"Anna", 95}, {"Béla", 88}, {"Cecília", 78}};

    for (const auto& [nev, pontszam] : diakok) {
        std::cout << nev << " pontszáma: " << pontszam << std::endl;
    }
    return 0;
}

• [nev, pontszam]: Az std::pair automatikusan szétbontásra kerül.
• Olvashatóbb és rövidebb kód.

---

8. Összehasonlítás hagyományos for és tartomány alapú for között

Hagyományos for ciklus (indexalapú)

#include <vector>
#include <iostream>

int main() {
    std::vector<int> szamok = {1, 2, 3, 4, 5};

    for (size_t i = 0; i < szamok.size(); i++) {
        std::cout << szamok[i] << " ";
    }
    return 0;
}

• Itt kézzel kezeljük az indexeket.
• Kevésbé olvasható és hajlamos a hibákra (pl. rossz indexkezelés).

Tartomány alapú for (egyszerűbb, biztonságosabb)

for (int szam : szamok) {
    std::cout << szam << " ";
}

• Nincs indexkezelés → egyszerűbb kód.
• Automatikus iteráció az elemek felett.

---

Összegzés

✅ Tartomány alapú for ciklus: egyszerűbb és hatékonyabb megoldás tömbök, vektorok, map és egyéb konténerek bejárására.
✅ Használjunk referenciát (&), ha el akarjuk kerülni az értékek másolását.
✅ const & használata ajánlott, ha csak olvasni akarjuk az adatokat.
✅ C++17 struktúrált kötés még kényelmesebb megoldás map bejárására.

További információk

• range-based for loop - Szótár.net (en-hu)
• range-based for loop - Sztaki (en-hu)
• range-based for loop - Merriam–Webster
• range-based for loop - Cambridge
• range-based for loop - WordNet
• range-based for loop - Яндекс (en-ru)
• range-based for loop - Google (en-hu)
• range-based for loop - Wikidata
• range-based for loop - Wikipédia (angol)