07. TANANYAG · FORRÁSKÓD
A for ciklus
07_for_kommentelt.csAnimáció megnyitása →
namespace _20250915_for // A namespace (névtér) összefogja és elkülöníti az ide tartozó kódelemeket; ennek a névtérnek a neve _20250915_for.
{ // Itt kezdődik a névtér kódblokkja.
internal class Program // A Program nevű osztály deklarációja. Az internal azt jelenti, hogy az osztály ezen az assemblyn belül érhető el.
{ // Itt kezdődik a Program osztály törzse.
static void Main(string[] args) // A Main a program belépési pontja; static: példány nélkül futtatható, void: nem ad vissza értéket.
{ // Itt kezdődik a Main metódus törzse.
// A for ciklust akkor használjuk, amikor előre jól meghatározható módon szeretnénk ismételni egy utasítássorozatot.
// Általános alakja: for (kezdőérték; ciklusban maradás feltétele; léptetés)
// A három rész pontosvesszővel van elválasztva egymástól.
// kezdőérték adás; ciklusban maradás feltétele; növekményes utasítás
// ciklusváltozó; meddig futhat a ciklus; ciklusváltozó növelése/csökkentése
// i++; eggyel növeli a változó értékét
// i--; eggyel csökkenti a változó értékét
// i változó hatóköre: a for ciklus blokkja
for (int i = 0; i < 10; i++) // Az i 0-ról indul, addig fut a ciklus, amíg i < 10, és minden kör végén i értéke 1-gyel nő. Python megfelelője: range(10).
{ // Itt kezdődik a for ciklus törzse.
Console.Write(i + " "); // Kiírja az i aktuális értékét és utána egy szóközt; az eredmény: 0 1 2 3 4 5 6 7 8 9
} // A blokk végén végrehajtódik az i++, majd újra ellenőrződik az i < 10 feltétel.
// i = 0; // Itt az i már nem létezik, mert a for fejlécében deklarált változó hatóköre csak a for ciklusra terjed ki.
Console.WriteLine(); // Üres sortörést ír ki, hogy a következő számsor új sorban kezdődjön.
for (int i = 10; i > 0; i--) // Az i 10-ről indul, addig fut, amíg nagyobb 0-nál, és minden kör után 1-gyel csökken.
{
Console.Write($"{i} "); // String interpolációval kiírja az i aktuális értékét; az eredmény: 10 9 8 ... 1
}
Console.WriteLine(); // A következő példa új sorban folytatódik.
for (int i = 2; i <= 20; i += 2) // Az i 2-ről indul, 20 még beletartozik a tartományba, és minden kör után 2-vel nő.
{
Console.Write($"{i} "); // Kiírja a páros számokat 2-től 20-ig.
}
Console.WriteLine(); // Új sort kezd.
for (int i = 100; i >= 0; i -= 3) // Az i 100-ról indul, amíg legalább 0, addig fut; minden kör után 3-mal csökken.
{
Console.Write($"{i} "); // Kiírja a sorozat aktuális elemét: 100, 97, 94, ... egészen addig, amíg a feltétel igaz.
}
// A for ciklus mindhárom része elhagyható.
// Ha a feltételt is elhagyjuk, akkor az alapértelmezetten mindig igaznak tekinthető,
// ezért az alábbi ciklus végtelen ciklus lenne, ha nem lenne kikommentelve.
//for (;;)
//{
// Console.WriteLine("bármi");
//}
} // Ez a záró kapcsos zárójel lezárja a Main metódust.
} // Ez a záró kapcsos zárójel lezárja a Program osztályt.
} // Ez az utolsó záró kapcsos zárójel lezárja a névteret.
/*
* A for CIKLUS
* ------------
*
* A for ciklus ismétlésre szolgáló vezérlési szerkezet.
* Különösen akkor kényelmes, ha egy számláló változó segítségével
* jól leírható, hogy hányszor vagy milyen értékekkel fusson le a ciklus.
*
* Általános alakja:
*
* for (kezdőutasítás; feltétel; léptetés)
* {
* ciklusmag
* }
*
* Például:
*
* for (int i = 0; i < 10; i++)
* {
* Console.WriteLine(i);
* }
*
* A for zárójelében három külön rész található:
*
* int i = 0 i < 10 i++
* ↓ ↓ ↓
* kezdőérték feltétel léptetés
*
* A részeket pontosvessző választja el.
*/
/*
* A for CIKLUS VÉGREHAJTÁSÁNAK SORRENDJE
* -------------------------------------
*
* A következő ciklus:
*
* for (int i = 0; i < 3; i++)
* {
* Console.WriteLine(i);
* }
*
* működése lépésenként:
*
* 1. int i = 0;
* Létrejön az i változó, kezdőértéke 0.
*
* 2. i < 3
* A program ellenőrzi a feltételt.
*
* 3. Ha a feltétel true:
* végrehajtódik a ciklus törzse.
*
* 4. i++
* A ciklusváltozó értéke eggyel nő.
*
* 5. A program visszatér a feltételhez.
*
* A konkrét értékek:
*
* i = 0 -> 0 < 3 -> true -> kiírja: 0
* i = 1 -> 1 < 3 -> true -> kiírja: 1
* i = 2 -> 2 < 3 -> true -> kiírja: 2
* i = 3 -> 3 < 3 -> false -> a ciklus véget ér
*
* Ezért a 3 már nem kerül kiírásra.
*/
/*
* A CIKLUSVÁLTOZÓ
* ----------------
*
* A for ciklusban gyakran használunk egy számláló változót:
*
* for (int i = 0; i < 10; i++)
*
* Az i elnevezés csak szokás.
* Lehetne például:
*
* for (int sorszám = 0; sorszám < 10; sorszám++)
*
* Az i gyakori neve az angol "index" vagy az iterációs változó
* hagyományos jelöléséből ered.
*
* Fontos, hogy az i nem valamilyen különleges C# kulcsszó:
* teljesen hagyományos változónév.
*/
/*
* i++ ÉS i--
* ----------
*
* Az:
*
* i++;
*
* röviden azt jelenti, hogy az i értékét eggyel növeljük.
*
* Egyszerűsítve ugyanaz a hatása, mint:
*
* i = i + 1;
*
* Hasonlóan:
*
* i--;
*
* az i értékét eggyel csökkenti.
*
* Egyszerűsítve:
*
* i = i - 1;
*
* Ezeket inkrementáló, illetve dekrementáló operátoroknak nevezzük.
*/
/*
* NEM CSAK 1-GYEL LEHET LÉPTETNI
* -----------------------------
*
* A léptetés tetszőleges megfelelő utasítás lehet.
*
* Például:
*
* i += 2
*
* jelentése:
*
* i = i + 2
*
* Ezért:
*
* for (int i = 2; i <= 20; i += 2)
*
* a következő értékeket veszi fel:
*
* 2, 4, 6, 8, 10, 12, 14, 16, 18, 20
*
* Ugyanez csökkentéssel:
*
* i -= 3
*
* jelentése:
*
* i = i - 3
*/
/*
* < ÉS <= KÜLÖNBSÉGE
* ------------------
*
* Nagyon fontos a ciklus feltételében használt relációs operátor.
*
* i < 10
*
* azt jelenti:
*
* i kisebb, mint 10
*
* A 10 már nem felel meg a feltételnek.
*
* Ezzel szemben:
*
* i <= 20
*
* azt jelenti:
*
* i kisebb vagy egyenlő 20-szal
*
* Ebben az esetben a 20 még része a ciklusnak.
*
* Ugyanez igaz a > és >= operátorokra is.
*/
/*
* A CIKLUSVÁLTOZÓ HATÓKÖRE
* ------------------------
*
* Ha a ciklusváltozót a for fejlécében hozzuk létre:
*
* for (int i = 0; i < 10; i++)
* {
* Console.WriteLine(i);
* }
*
* akkor az i változó csak a for ciklushoz tartozó területen érhető el.
*
* A ciklus után:
*
* i = 0;
*
* már fordítási hibát okozna, mert ott az i változó nem létezik.
*
* Emiatt egymás után több for ciklusban is létrehozható újra
* egy új, szintén i nevű változó:
*
* for (int i = 0; i < 10; i++)
* {
* }
*
* for (int i = 10; i > 0; i--)
* {
* }
*/
/*
* NÖVEKVŐ ÉS CSÖKKENŐ CIKLUS
* --------------------------
*
* Növekvő ciklus:
*
* for (int i = 0; i < 10; i++)
*
* Az i értéke egyre nagyobb.
*
* Csökkenő ciklus:
*
* for (int i = 10; i > 0; i--)
*
* Az i értéke egyre kisebb.
*
* Fontos, hogy a feltétel és a léptetés összhangban legyen.
*
* Például:
*
* for (int i = 10; i > 0; i++)
*
* problémás lenne, mert i egyre nő, miközben a feltétel azt várja,
* hogy egyszer majd ne legyen nagyobb 0-nál.
* Ez ezért végtelen ciklushoz vezetne.
*/
/*
* for (;;) – VÉGTELEN CIKLUS
* -------------------------
*
* A for ciklus három része külön-külön elhagyható.
*
* Ez is érvényes C#:
*
* for (;;)
* {
* Console.WriteLine("bármi");
* }
*
* Mivel nincs megadva kilépési feltétel, a ciklus folyamatosan futna.
*
* Ez végtelen ciklus.
*
* Végtelen ciklus nem feltétlenül hiba:
* bizonyos programokban szándékosan is használható,
* de ilyenkor általában valamilyen más módon gondoskodunk a kilépésről,
* például break utasítással.
*/
/*
* C# for ÉS PYTHON range()
* ------------------------
*
* Pythonban gyakori:
*
* for i in range(10):
*
* Ez a következő értékeket adja:
*
* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
*
* C#-ban ugyanez hagyományos for ciklussal:
*
* for (int i = 0; i < 10; i++)
* {
* }
*
* A C# for ciklusa általánosabb szerkezet:
* külön megadjuk a kezdőértéket, a folytatás feltételét és a léptetést.
*/
namespace _20250915_for
{
internal class Program
{
static void Main(string[] args)
{
for (int i = 0; i < 10; i++)
{
Console.Write(i + " ");
}
Console.WriteLine();
for (int i = 10; i > 0; i--)
{
Console.Write($"{i} ");
}
Console.WriteLine();
for (int i = 2; i <= 20; i += 2)
{
Console.Write($"{i} ");
}
Console.WriteLine();
for (int i = 100; i >= 0; i -= 3)
{
Console.Write($"{i} ");
}
}
}
}