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);
}

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:

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

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.

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