A InfoWiki wikiből

Előírt lépésszámú ciklusok

Magasszintű Programozási Nyelvek I.

Imperatív, procedurális nyelvek alapjai

Hernyák Zoltán

Kezdőlap

Jegyzetek

Tartalomjegyzék

Gyakorlatok

Vizsgatematika

Programok C# nyelven

Előírt lépésszámú ciklusok

Tekintsük meg az alábbi kódot:

int i=0;
while (i<10)
{
  ...
  i++;
}

A fenti while ciklus a ciklusmagját 10-szer fogja végrehajtani, mivel az i változó induló értéke 0, minden menetben az i értéke pontosan 1-el nő, és akkor fogja elhagyni a ciklust, ha az i értéke elérte (vagy meghaladta) a 10 értéket.

Gyakoriak azok az esetek, amikor előre ismert, hogy a ciklusmag hányszor kerül majd végrehajtásra. Ez esetben a fentihez hasonló while ciklus alkalmazható, de nem túl szerencsés az alkalmazása. Az információk, amelyből a kiderül, hogy ez a ciklus 10-szer ismétlődik majd - a kódban szétszórtan helyezkedik el. Ráadásul az i változó deklarációja meg kell előzze a while ciklus indulását, így hatásköre (és az élettartama) nem a ciklusra korlátozódik, hanem a ciklus lefutása után is megmarad.

A fenti problémák kezelésére speciális ciklusfajta szolgál, a for ciklus.

FOR fejrésze

A for ciklus fejrésze három részre osztható, melyeket kettő darab pontosvessző határol. A részek szerepe:

• az inicializáló utasítás (mely a ciklus kezdetekor egyszer hajtódik végre
• a ciklus vezérlő feltétele (pozitív vezérlésű a for ciklus)
• a léptető utasítás (mely a ciklusmag lefutása után automatikusan kerül végrehajtásra)

Példa:

for(int i=0; i<10; i++)
{
  Console.Write(i);
}

A fenti példa teljesen megfelel a korábban ismertetet while ciklus példában szereplő kód működésével. Az i változó azonban itt a ciklusra lokális, tehát a for ciklus törzsén túl már nem terjed a hatásköre. A ciklusmag minden lefutása után végrehajtódik az inkrementáló utasítás, vagyis az i értéke nő 1-el.

A példában szereplő for ciklus fejrészében minden információ szerepel, melyből meghatározható, hogy ez a for ciklus pontosan 10-szer fog lefutni. A ciklusmagban az i változó értéke kiolvasható, de megváltoztatása tilos. Ennek oka, hogy az i változó értékének átírása a pontos 10 ismétlést módosítaná (vagy kevesebbszer, vagy többször kerülne végrehajtásra).

Példa

Hibás tehát az alábbi példa (bár nem szintaktikailag, hanem elvi, stílusbeli hiba). A programban a 10 elemű tömböt csak pozitív számokkal kívánjuk feltölteni. Amennyiben a program kezelője valamely elem értékének negatív számot kíván megadni, azt az elemet újra bekérjük:

int[] tomb = new tomb[10];
for(int i=0;i<10;i++)
{
  Console.Write("{0}. szám értéke:");
  tomb[i] = int.Parse(Console.ReadLine());
  if (tomb[i]<0) i--;
}

A feltételben az i-- utasítás az i értékét csökkenti 1-el, amit az inkrementáló utasítás (i++) meg fog növelni 1-el. E miatt negatív szám beírása esetén az i értéke gyakorlatilag nem fog változni - a ciklus következő lefutásakor is ugyanazon i tömbelem kerül feltöltésre.

Ez elegánsabban megoldható while ciklussal:

int[] tomb = new tomb[10];
int i=0;
while (i<10)
{
  Console.Write("{0}. szám értéke:");
  tomb[i] = int.Parse(Console.ReadLine());
  if (tomb[i]>0) i++;
}

Vagyis csak akkor lépünk a következő tömbelem bekérésére, ha ezen tömbelemmel elégedettek vagyunk.

Másik lehetséges megoldás:

int[] tomb = new tomb[10];
for(int i=0;i<10;i++)
{
  do
  {
    Console.Write("{0}. szám értéke:");
    tomb[i] = int.Parse(Console.ReadLine());
  } 
  while (tomb[i]<0);
}

Ez esteben az i-edik tömbelem bekérésől addig nem lépünk tovább, amíg annak értékével elégedettek nem vagyunk.