Ciklusok: A Programozás Ismétlődő Feladatai 🔁

A ciklusok a programozás „ismétlődő mozdulatai”. Ahelyett, hogy sokszor leírnád ugyanazt a kódot, a ciklusokkal egyszerűen megmondhatod a programnak, hogy egy kódrészletet hányszor, vagy milyen feltétel teljesüléséig ismételjen meg. Ez rengeteg időt és energiát spórol neked! ⏱️

for ciklus: A Számlálómester (Elöltesztelős) 🔢

A for ciklus a leggyakrabban használt ciklustípus, különösen akkor, ha előre tudjuk, hányszor kell megismételni valamit. Gondolj egy tömb elemeinek feldolgozására: ha van egy 20 elemű tömböd, sokkal egyszerűbb egy for ciklussal végigmenni rajta, mint 20 külön sorban begépelni ugyanazt!

Nézzünk egy példát: egy 20 elemű statikus tömbbe bekérjük a felhasználótól az elemeket.

#include <iostream> // A cout és cin használatához
#include <string>   // Opcionálisan, ha stringeket is használnánk
int main() {
    const int ELEMSZAM = 20; // A tömb mérete, konstansként megadva
    int szamok[ELEMSZAM];   // Egy 20 elemű int tömb
    // A for ciklus: i = 0-tól indul, amíg i < ELEMSZAM (azaz 19-ig megy), 
és minden lépésben növeli i-t
    for (int i = 0; i < ELEMSZAM; ++i) {
        std::cout << "Kerem adja meg a(z) " << i + 1 << ". szamu elemet: "; 
// Figyeld az i+1-et a számozáshoz!
        std::cin >> szamok[i]; // Beolvassuk az i-edik (aktuális) elem értékét
    }
     // Opcionálisan ki is írathatjuk a tömb elemeit, hogy ellenőrizzük:
    std::cout << "\nBekert elemek:\n";
    for (int i = 0; i < ELEMSZAM; ++i) {
        std::cout << "A(z) " << i + 1 << ". elem: " << szamok[i] << std::endl;
    }
    return 0;
}

 

Hogyan is működik a for ciklus? 🤔

A for ciklus három részből áll, amiket zárójelek között, pontosvesszővel (;) elválasztva adunk meg:

for (/*1. Inicializálás*/; /*2. Feltétel*/; /*3. Lépésköz*/) {
    // A ciklusmag, azaz az ismétlendő utasítások
}

1. Inicializálás (int i = 0;): Itt hozzuk létre (és gyakran inicializáljuk) a ciklusváltozót (általában i-nek, j-nek, k-nak nevezik, főleg egymásba ágyazott ciklusoknál). Ez a változó segít számon tartani, hányadik lépésnél tart a ciklus. Ez a rész csak egyszer fut le, a ciklus elején.
• Fontos! A ciklusváltozó (pl. i) csak a ciklusmagban érhető el! Ha a for blokkján kívül próbálsz rá hivatkozni, a program nem fog lefordulni! 🚫
2. Feltétel (i < ELEMSZAM;): Ez egy logikai kifejezés, amit a ciklus minden egyes ismétlés előtt kiértékel.
• Ha a feltétel true (igaz), a ciklusmag (a kapcsos zárójelek közötti rész) lefut.
• Ha a feltétel false (hamis), a ciklus leáll, és a program a ciklus utáni első utasítással folytatódik.
• Példánkban: amíg i kisebb, mint az ELEMSZAM (20), a ciklus megy. Amint i eléri a 20-at, a feltétel (20 < 20) hamissá válik, és a ciklus leáll. Ez biztosítja, hogy ne indexeljük túl a tömböt (a 0-tól 19-ig terjedő indexek megfelelőek egy 20 elemű tömbhöz)! 🎯
3. Lépésköz (++i): Ez az utasítás a ciklusmag minden egyes lefutása után hajtódik végre. Itt szoktuk növelni vagy csökkenteni a ciklusváltozó értékét.
• ++i vagy i++: Növeli i értékét 1-gyel. (A ciklus szempontjából ugyanazt teszik.)
• –i vagy i–: Csökkenti i értékét 1-gyel.
• i += 2: Növeli i értékét 2-vel (ugyanaz, mint i = i + 2;, de a for paraméterében az i += 2 a szintaktikailag helyesebb).

Nem csak tömbökhöz! A for ciklust nem csak tömbök feldolgozásához használhatjuk! Bármilyen előre meghatározható lépésszámú művelethez ideális. A leggyakoribb internetes példa: számok kiíratása 0-tól 99-ig:

for (int i = 0; i < 100; ++i) {
    std::cout << i << " ";
}
std::cout << std::endl; // Új sor a végére

continue utasítás: Az „Átugrom ezt a lépést!” 🚧

Néha a ciklusban azt szeretnénk, hogy ha egy bizonyos feltétel teljesül, akkor az adott lépésben hagyja ki a ciklusmag hátralévő utasításait, de utána folytatódjon tovább a következő lépéssel. Erre való a continue; utasítás!

Ez hasznos lehet, ha például egy tömb feldolgozásánál bizonyos elemeket figyelmen kívül akarunk hagyni.

for (int i = 0; i < 100; ++i) {
    std::cout << i << " ";
}
std::cout << std::endl; // Új sor a végére
for (int i = 0; i < 10; ++i) {
    // Ez az utasítás MINDENKÉPPEN lefut
    std::cout << "Jelenlegi i: " << i << " - ";
    if (i % 2 != 0) { // Ha az i páratlan szám
        std::cout << "Paratlan szam, kihagyom a tobbi utasitast ebben a lepesben." 
<< std::endl;
        continue; // Ugorj a ciklus következő lépésére!
    }
    // Ezek az utasítások CSAK akkor futnak le, ha az i páros volt
    std::cout << "Paros szam, tovabbi utasitasok futnak." << std::endl;
}

Láthatod, hogy a continue miatt nem kell else ágba tennünk a „további utasításokat”, mert ha a feltétel igaz, egyszerűen átugrik a következő iterációra.

break utasítás: A „Megállj, elég volt!” 🛑

Ha azt szeretnénk, hogy a ciklus egy bizonyos feltétel teljesülése esetén azonnal álljon le, és ne fusson tovább, akkor a break; utasítást használjuk. Ez nem csak a jelenlegi lépés hátralévő részét hagyja ki, hanem a teljes ciklust leállítja! (Emlékszel, a switch-case esetén is használtuk a break-et, hogy megállítsuk az átesést a következő case-re?)

for (int i = 0; i < 10; ++i) {
    std::cout << "Jelenlegi i: " << i << std::endl;
    if (i == 5) { // Ha i eléri az 5-öt
        std::cout << "I elerte az 5-ot, leallitom a ciklust!" << std::endl;
        break; // A ciklus azonnal leáll!
    }
}
std::cout << "A ciklus vege." << std::endl;
// A fenti kód csak 0-tól 5-ig fog kiírni, utána leáll.

do-while ciklus: Az „Először csinálom, aztán kérdezem” (Hátultesztelős) 🔄

A do-while ciklus egy úgynevezett hátultesztelős ciklus. Ez azt jelenti, hogy a ciklusmagban lévő utasítások egyszer biztosan lefutnak, és csak utána ellenőrzi a feltételt. Ha a feltétel igaz, akkor ismétli a ciklust, különben leáll.

Ez tökéletes olyan helyzetekre, ahol legalább egyszer meg kell csinálni valamit, mielőtt eldöntjük, hogy megismételjük-e. Például, adatbevitel ellenőrzésére vagy egy menü ismételt megjelenítésére.

Szerkezete:

do {
    // Ezek az utasítások legalább egyszer lefutnak!
    // ...
} while ( /*feltétel*/ ); // Itt ellenőrzi a feltételt a futás után!

Példa: Program ismételt végrehajtása felhasználói kérésre

#include <iostream>
int main() {
    char valasz;
     do {
        std::cout << "------------------------" << std::endl;
        std::cout << "Program fut! (Csinald a dolgod!)" << std::endl;
        std::cout << "------------------------" << std::endl;
        std::cout << "Szeretne ujra vegrehajtani a programot? (i/n): ";
        std::cin >> valasz; // Bekérjük a választ
        std::cout << std::endl; // Egy üres sor a jobb olvashatóságért
    } while (valasz == 'i' || valasz == 'I'); 
// Amíg 'i' vagy 'I' a válasz, addig ismételjük
    std::cout << "Viszlat! 👋" << std::endl;
    return 0;
}

while ciklus: Az „Amíg a feltétel igaz” (Elöltesztelős) ⏳

A while ciklus is egy elöltesztelős ciklus, akárcsak a for ciklus. Ez azt jelenti, hogy a feltételt a ciklusmag futása előtt ellenőrzi. Ha a feltétel már az elején hamis, akkor a ciklusmag egyszer sem fut le.

A while ciklus akkor hasznos, ha nem tudjuk előre a lépések számát, de tudjuk, milyen feltételnek kell teljesülnie az ismétléshez.

Szerkezete:

while ( /*feltétel*/ ) {
    // Ezek az utasítások futnak, amíg a feltétel igaz
    // Fontos: itt kell gondoskodni arról, 
hogy a feltétel egyszer hamissá váljon,
    // különben végtelen ciklusba kerül a program! 😱
}

 Példa: Egy egész szám számjegyeinek száma

Gondoljunk bele: hogyan számolnánk meg egy szám jegyeit, ha nem tudjuk, hány jegyből áll? Egy while ciklussal egyszerűen megoldható! Az int típusú szám 10-zel való osztása (egészosztás) valójában az utolsó számjegy elhagyását jelenti. Pl. 128 / 10 (egészosztásban) eredménye 12.

#include <iostream>
int main() {
    int szam;
    std::cout << "Kerem adjon meg egy egesz szamot: ";
    std::cin >> szam;
    std::cout << "A beolvasott szam: " << szam << std::endl;
    if (szam == 0) { // Speciális eset a 0-ra
        std::cout << "A szamjegyek szama: 1" << std::endl;
        return 0;
    }
    int szamjegyek = 0; // Számláló a számjegyeknek
     // A ciklus addig fut, amíg a 'szam' nem lesz 0
    // A 'szam /= 10' azt jelenti, hogy 'szam = szam / 10' (egészosztás)
    while (szam != 0) { 
// Alternatíva: while (szam) { ... } mert 0 false-nak konvertálódik
        szam /= 10;     // Elhagyjuk az utolsó számjegyet
        szamjegyek++;   // Növeljük a számjegyek számát
    }
    std::cout << "A szamjegyek szama: " << szamjegyek << std::endl;
    return 0;
}

Figyelem! Ebben a példában az int szamjegyek = 1; inicializálást megváltoztattam int szamjegyek = 0;-ra, és hozzáadtam egy if (szam == 0) ellenőrzést, mert a while (szam /= 10) feltétel a 0-át speciálisan kezeli (ha 0, egyszer sem fut le a ciklus, és 0 számjegyet adna vissza, ami hibás). Így sokkal robosztusabb a kód! 💪

Ezzel a ciklusokról szóló fejezettel már igazán komoly programokat írhatsz, amik képesek ismétlődő feladatokat elvégezni! Gyakorolj sokat, mert a ciklusok használata kulcsfontosságú a programozásban! 🔑