Ciklusok

A szekvencia és az elágazás mellett a harmadik vezérlési szerkezet, a ciklus vagy loop.

Ha azt szeretnénk, hogy egy programrész egymás után többször fusson le, ciklust használunk.

Vegyük a következő példát: Írjuk ki az első 100 természetes számot.

int i = 1;          // Létrehozunk egy int változót, egyes kezdőértékkel
										// Ezt a változót ciklusváltozónak vagy indexnek nevezzük
while (i <= 100)    // Addíg fut a ciklus, amíg i érték-e kisebb vagy egyenlő 100-zel
{
		Debug.Log(i);   // Kiírjuk a konzolra a változó értékét
		i++;            // Növeljük a változó értékét eggyel
}

A ciklus addig nem fejeződik be, amíg a fejlécben megadott bool típusú kifejezés, azaz a ciklus feltétele igaz.

Az a ciklust, ami sosem fejeződik be végtelen ciklusnak nevezzük és legtöbb esetben a program teljes lefagyását eredményezi. Nagyon vigyázzunk, hogy ezt elkerüljük!

Ha például elfelejtettem volna az i++ sort leírni a fenti példa és végtelen ciklust eredményezett volna.

Vegyük észre, hogy a példa beli ciklus törzse 100-szor fut le és mindig egy kicsikét különböző dolgot fog végrehajtani ugyanaz a kódrészlet: Más számot ír ki. Ez ezért lesz így mert az i változó értéke a ciklus törzsének lefutásai közt változik.

A for avagy számláló ciklus

A fenti példa egy gyakori felhasználását mutatja. Ezt az jellemzi, hogy egy ciklusváltozót használunk arra, hogy számon tartjuk egy információt a ciklusunk futásáról, például, hogy eddig hányszor hajtottuk azt végre. És a ciklus végén mindig egységesen változtatunk valamit a ciklusváltozón.

Ezen tipusú ciklusokra létezik egy egyszerűsített leírás:

for (int i = 1; i <= 100; i++)
{
		Debug.Log(i);
}

A ciklus törzsében így 3 információt adunk meg pontos vesszővel elválasztva:

A ciklusváltozó deklarálása és definiálása
A ciklus feltétele (Hasonlóan a while-hoz)
minden egyes lefutás után végrehajtandó művelet. (Általában a ciklusváltozón)

Ebben az esetben a ciklust törzsét képező blokk egy soros, így a kapcsos zárójelek opcionálisan elhagyhatók.

Ciklusok “visszafelé” is futtathatók:

Írjuk ki az első 100 számot visszafelé!

for (int i = 100; i > 0; i--)
{
		Debug.Log(i);
}

Írjuk ki az első 50 páros számot visszafelé!

for (int i = 100; i > 0; i-=2)
{
		Debug.Log(i*i);
}

A hátultesztelő ciklus

Előfordul, hogy azt szeretnénk, hogy egy ciklus egyszer mindenképp lefusson és utána teszteljen csak egy feltételre. Ebben az esetben hátul tesztelő ciklust használhatunk.

int i = 1;          // Létrehozunk egy ciklusváltozónak, egyes kezdőértékkel
do                  // Ciklus induljon el
{
		Debug.Log(i);   // Kiírjuk a konzolra a változó értékét
		i++;            // Növeljük a változó értékét eggyel
}
while (i <= 100);   // Addíg fut a ciklus, amíg i érték-e kisebb vagy egyenlő 100-zel

Ciklusok és elágazások egymásba ágyazása

Ciklusok és elágazások egymásba ágyazhatók. Példának vizsgáljuk meg a következő kódrészleteket:

Írjuk ki az első szorzótáblát!

for (int i = 1; i <= 10; i++)
{
		for (int j = 1; j <= 10; j++)
		{
				Debug.Log($"{i}-szer {j} = {i*j});
		}
}

Írjuk ki az első 10 számot ami osztható 3-mal vagy 3-tel!

int count = 0;
for (int i = 1; count < 10; i++)
{
		bool devidableWith3 = i % 3 == 0;
		bool devidableWith7 = i % 7 == 0;

		if(devidableWith3 || devidableWith7)
		{
				Debug.Log(i);
			  count++;
		}
}

Ciklus megszakítása

A teljes ciklus futása megszakítható a break paranccsal. Nézzük a következő példát.

Írjuk kódot, ami eldönti egy számról, hogy prím-e.

bool isPrime = true; // Jelen módszerrel abból indulunk ki, hogy egy szám prím akkor,
                     // ha az ellentéte nem igazolódik, azáltal hogy találunk egy
                     // tőle kissebb (1-nél nagyobb) számot, amivel osztható.

for (int i = 2; i < number; i++)   // Megnézzük ez összes számot 2-től number-1-ig.
{
    if (number % i == 0)  // Ha csak egyet számot is találunk, amivel osztható "number",
    {
        isPrime = false;  // akkor biztosak lehetünk benne hogy a szám nem prím.
        break;            // Nem érdemes tovább futtatni a ciklust: Megszakítjuk azt
    }
}
// A break után innen folytatódik a kód futása...

Ha a ciklusnak csak az egyik lefutását akarjuk megszakítani és nem az egész ciklust, a continue parancsot használjuk:

bool isPrime = true;  // Jelen módszerrel abból indulunk ki, hogy egy szám prím akkor,
                      // ha az ellentéte nem igazolódik, azáltal hogy találunk egy
                      // tőle kissebb (1-nél nagyobb) számot, amivel osztható.

for (int i = 2; i < number; i++)  // Megnézzük ez összes számot 2-től number-1-ig.
{
    if (number % i != 0)  // Ha a szám nem osztható, akkor még lehet prim.
    {
        continue;         // Továbbugrunk a következő végrehajtásra.
													// A ciklustőrzs további részét átugorjuk.
    }

    isPrime = false;     // Találtunk egy osztót: Nem prím
    break;               // Nem érdemes tovább futtatni a ciklust: Megszakítjuk azt
}