A Turbo Pascal ciklusszervezõ utasítasai

A Turbo Pascal ciklusszervezõ utasításai

A ciklusokról általában:

A programok írása során gyakran felmerülõ probléma, hogy egy utasítást egymás után többször meg kellene ismételni. Az ilyen ismétlõdõ tevékenységek programnyelven történõ megfogalmazását 535j92f segítik a ciklusszervezõ utasítások. Általában minden magasszintû programozási nyelvben megtalálhatók ezek az utasítások. Az alacsonyszintû programozási nyelveknél (assembbly, gépi kód) egy feltételes utasítás és egy ugró utasítás kombinációjával lehet az ilyen jellegû feladatokat megoldani.

A Pascal nyelv háromféle ciklusszervezõ utasítással segíti a programozást:
- For ciklus: akkor célszerû alkalmazni, amikor elõre ismerjük a tevékenység (uatítások) ismétlésének számát
- While ... do ciklus: akkor célszerû alkalmazni, amikor nem tudjuk elõre, hányszor kell a tevékenységet megismételni
- Repeat ... Until ciklus: a While ... do ciklushoz hasonlóan nem szükséges elõre ismerni az ismétlések számát, mégis különbséget kell tennünk a két ciklus között, a késõbbiek látni fogjuk, mi a különbség közöttük, mikor melyiket célszerû alkalmazni.
 

A ciklusok felépítése, csoportosítása:

A ciklusok két részbõl épülnek fel:
- Az ismétlések számát meghatározó ciklusfej (amely általában a ciklusutasítást, vagy annak egy részét is tartalmazza)
- Az ismétlõdõ utasítás(oka)t tartalmazó ciklusmag, amely az ismétlõdõ tevékenység leírását tartalmazza
A ciklusfejben található az ún. ciklusfeltétel, amely meghatározza, hogy a ciklus ismétlése milyen feltétel teljesülése esetén fejezõdik be.

A ciklusszervezõ utasításokat általában a ciklusfeltétel kiértékelésének helye alapján szoktuk csoportosítani:
- Elöltesztelõ ciklus: A ciklusfeltétel kiértékelése a ciklusmag lefutása elõtt történik. Ilyen a For és a While ... do ciklus.
- Hátultesztelõ ciklus: A ciklusfeltétel kiértékelése a ciklusmag után történik. Ilyen a Repeat ... Until ciklus.

Pontos definíció, általános szabály nem létezik arra, hogy mikor melyik ciklust érdemes alkalmazni, ezt mindig a probléma jellege dönti el, mégis néhány szempontot érdemes figyelembe venni:
- Ha elõre tudjuk, hogy a ciklusmagot hányszor kell végrehajtani, célszerû a For ciklust alkalmazni. (Példa: Az elsõ N db természetes szám összegének meghatározása)
- Ha a ciklusmagot legalább egyszer végre kell hajtani, célszerû a Repeat ... Until ciklust választani. (Példa: Olvassunk be természetes számokat 0 végjelig.)
- Ha azt szeretnénk, hogy a ciklusmag csak egy feltétel teljesülése esetén fusson le, illetve ha ez a feltétel nem teljesül, akkor a ciklusmagot egyszer sem szeretnénk végrehajtani, célszerû a While ... do ciklust alkalmazni. (Példa: Jelenítsük meg a képernyõn egy szöveges állomány tartalmát.)
 

A For ciklus:

A For ciklust akkor érdemes alkalmazni, amikor elõre meg tudjuk határozni az ismétlések számát. A For ciklus elõltesztelõ ciklus. A For ciklust két formában alkalmazhatjuk:

For ciklusváltozó:= kezdõérték to végérték do ciklusmag;

illetve

For ciklusváltozó:= kezdõérték downto végérték do ciklusmag;

Az elsõ változat esetén a ciklusváltozó értéke növekedni fog (minden ismétléskor 1-gyel), amíg el nem éri a végértéket. A második változatnál a ciklusváltozó értéke minden ismétléskor 1-gyel csökken, amíg el nem éri a végértéket. A do foglalt szó után következõ ciklusmag egy utaítást tartalmazhat, ha több utasítást szeretnénk a ciklusmagban elhelyezni, a begin ... end; utasításokat kell alkalmaznunk. A ciklusmag ismétléseinek száma a következõképpen határozható meg:
- növekvõ (to) ciklus esetén: ismétlésszám=végérték-kezdõérték
- csökkenõ (downto) ciklus esetén: ismétlésszám=kezdõérték-végérték

A For ciklusmagjának utasításai csak akkor kerülnek végrehajtásra, ha:
- növekvõ (to) ciklus esetében teljesül a kezdõérték<=végérték
- csökkenõ (downto) ciklus esetében teljesül a kezdõérték=végérték
feltétel.
Egyébként a ciklusmagban elhelyezett utasítás(ok) egyszer sem kerülnek végrehajtásra.

A For ciklus esetében a ciklusváltozó értékének változtatása automatikusan történik, a ciklusmag minden egyes végrehajtása után növekszik vagy csökken az értéke. Ezért a ciklusmagon belül nem "illik" a ciklusváltozó értékét megváltoztatni, mert ez a ciklus mûködését kiszámíthatatlanná teszi. Az elméleti lehetõsége azonban adott, a ciklusváltozó értéke a ciklusmagon belül megváltoztatható, szintaktikai hibát nem okoz (legrosszabb esetben végtelen ciklust hozunk létre). A For ciklus ciklusváltozója - az automatikus léptetés miatt - csak sorszámozott tipus lehet, más tipusok esetén 97-es kódú hibát kapunk a program fordítása során, a fordító jelzi, hogy ilyen tipusú változó a For ciklusnál nem használható.

A For ciklust alkalmazzuk általában a tömbök kezelése során, összegzéskor, stb.
 
 

Példák a For ciklus alkalmazására:

Számítsuk ki az elsõ N db természetes szám összegét!

Var N: integer;
      Sum: longint;
Begin
    Write('N= ');
    Readln(N);
    For N:=0 to N do
        Sum:= Sum+N;
    Writeln('Az elso ', N, ' termeszetes szam osszege: ', Sum);
End.
 

Töltsünk fel egy 10 elemû tömböt [1..90] közé esõ véletlenszámokkal!

Var Tomb: Array [1..10] of integer;
      I: byte;
Begin
    Randomize;
    For I:= 1 to 10 do
        Begin
            Tomb[I]:= Random(90)+1;
            Writeln('A tomb ', I, '. eleme: ', Tomb[I];
        End;
End.

Mivel a For ciklus magjában több utasítást is elhelyeztünk, szükséges volt azokat a Begin ... End; közé elhelyezni. A Randomize utasítás a véletlenszámok generálását teszi lehetõvé, a Random függvény pedig a véletlenszámokat állítja elõ. A Random(MAX) függvény egy [0..MAX-1] intervallumba esõ egész számot ad vissza, ezért kell 1-et hozzáadni.
 

A While ... do ciklus:
 
 A While ... do ciklus a For ciklushoz hasonlóan elõltesztelõ ciklus, de az elõbbivel szemben nem kötelezõ a ciklusba lépéskor meghatározni a ciklus iterációinak (ismétlésének) számát. A While ... do ciklus szintaktikája:

While ciklusfeltétel do
utasítás;

A ciklusmag addig ismétlõdik, amíg a ciklusfeltétel igaz. A For ciklushoz hasonlóan a ciklusmag itt is egy utasításból áll, ha több utasítást szeretnénk a ciklusmagban szerepeltetni, akkor a Begin ... End; foglalt szavak között kell õket elhelyezni. A While ... do ciklus esetében - szemben a For ciklussal, amely ilyen értelemben rendhagyó - a ciklusfeltétel értékét nekünk kell változtatni a ciklusmagon belül! Amennyiben ezt nem tesszük meg, és a ciklusfeltétel igaz értéke a ciklusmagon belül nem változik meg, akkor végtelen ciklust kapunk. Nagyon gyakori hibalehetõség!
A While ... do ciklus ciklusmagjának utasításai csak akkor kerülnek végrehajtásra, ha a ciklusba lépéskor a ciklusfeltétel igaz. Amennyiben a ciklusfeltétel hamis, a ciklusmag végrehajtása egyszer sem történik meg.
A While ... do ciklus ciklusfeltétele egy logikai kifejezés vagy változó (nem véletlenül írtam ebben a sorrendben az elsõt sokkal gyakrabban használjuk). Ha más tipust szeretnénk alkalmazni ciklusfeltételként a fordító 40-es hibaüzenetet küld, amely azt jelzi, hogy a fordító logikai tipusú kifejezést vagy változót vár az adott helyen.

A While ... do ciklust általában filekezelésnél használjuk, mert ha egy üres állományból olvasunk, az EOF függvény tesztelésével már a ciklus elején kiszûrhetjük ezt az információt, a program nem fut feleslegesen (programtól függõen minimum 5-6 utasítás végrehajtásának idejét megspórolhatjuk).

Példák a While ... do ciklus alkalmazására:

Olvassunk be egy számot, döntsük el, prímszám-e:

Var A: Integer;
      O: Integer;
      Prim: Boolean;
Begin
    Write('Kerek egy egesz szamot: ');
    Readln(A);
    Prim:= True;
    O:= 2;
    While (O<Sqrt(A)) do
        Begin
            if (A mod O)=0
        then Prim:= False;
            O:= O+1;
        End;
    If Prim
        then Writeln('Primszam')
        else Writeln('Nem primszam');
End.

A szám beolvasása után egy ciklust futtatunk, amelyben vizsgáljuk, hogy a szám osztható-e maradék nélkül valamely 1-tõl és önmagától különbözõ számmal (ezért O:= 2, a ciklusváltozó indulóértéke). A ciklus akkor ér véget, ha elérjük a szám négyzetgyökét (O<Sqrt(A)). A ciklusba lépés elõtt a számról feltételezzük, hogy prim, ezért az ún. jelzõváltozó (Prim) értékét igazra állítjuk. Ha a ciklus futása során találunk olyan számot, amellyel az A szám maradék nélkül osztható, a jelzõváltozó értékét hamisra állítjuk, mert mostmár tudjuk, hogy a szám nem prímszám. Ha nem találunk ilyen számot, a jelzõváltozó értéke a ciklus végéig nem változik. A ciklusból kilépve a Prim változó értéke alapján tudjuk eldönteni, hogy elõfordult-e olyan szám, amely valódi osztója volt a beolvasott számnak.
 

Írjuk ki a képernyõre az AUTOEXEC.BAT állomány tartalmát:

Var F: Text
      S: String;
Begin
   
    Assign(F, 'C:\AUTOEXEC.BAT');
    Reset(F);

   
   
    While (not Eof(F)) do
        Begin
           Readln(F, S);
           Writeln(S);
        End;

   
    Close(F);
End.

A példban a While ... do ciklus alkalmazása volt a legcélszerûbb, mert amennyiben az állomány üres, akkor a ciklusmagot figyelmen kívül hagyta volna a program. A For ciklust nem tudtuk volna alkalmazni, mert nem tudjuk elõre megmondani, hogy az állomány hány sort tartalmaz (nem tudtuk volna hol fejezzük be a ciklust!). A ciklusfeltétel: az Eof függvény akkor ad vissza igaz értéket, ha a file végén állunk (bõvebben lásd a filekezelésnél), ezt a kifejezést nyilván "meg kell fordítanunk", negálnunk kell, ezt a not operátor segítségével tettük meg.
 

A Repeat ... Until ciklus:

A Repeat ... Until ciklus a Pascal nyelv egyetlen hátultesztelõ ciklusa. A While ... do ciklushoz hasonlóan nem kötelezõ elõre meghatározni az iterációk számát. A Repeat ... Until ciklus szintaktikája:

Repeat
    utasítás_1;
    utasítás_2;
    .
    .
    .
    utasítás_n;
Until ciklusfeltétel;

A ciklusmag addig ismétlõdik, amíg a ciklusfeltétel hamis. Az eddigi ciklusutasításokhoz képest eltérés, hogy a ciklusmag több utasítást is tartalmazhat, a Begin ... End; utasítászárójelek használata lehetséges, de nem kötelezõ. A ciklusfeltétel értékét ennél a ciklustipusnál is nekünk kell változtatni, nincs automatikus léptetés. A ciklusfeltétel változtatása itt is a ciklusmagon belül kell történjen, elmulasztása hasonó hibákat okoz, mint a While ... do ciklus esetében.
A Repeat ... Until ciklus ciklusmagja minden esetben végrehajtásra kerül legalább egyszer, akkor is, ha a ciklusfeltétel a ciklusba lépéskor már igaz (ebben az esetben azonban a ciklusmag megismétlésére nem kerül sor).
A Repeat ... Until ciklus ciklusfeltétele egy logikai kifejezés vagy változó (hasonlóan a While ... do ciklushoz, itt is gyakrabban fordul elõ a kifejezés). Ha más tipust szeretnénk alkalmazni ciklusfeltételként a fordító 40-es hibaüzenetet küld, amely azt jelzi, hogy a fordító logikai tipusú kifejezést vagy változót vár az adott helyen.

A Repeat ... Until ciklust általában akkor alkalmazzuk, ha több adat beolvasására kerül sor, és az adatsor végét végjel határozza meg, ha a program végén szeretnénk várni egy billentyû leütéséig kilépés elõtt, vagy ha valamilyen több lépésbõl álló tevékenységet szeretnénk egymás után többsször végrehajtani (lásd a Pascal feladatoknál a grafikus példák 8. feladatát!).

Példák a Repeat ... Until ciklus alkalmazására:
 
 Olvassunk be egész sztámokat 0 végjelig, határozzuk meg a számok átlagát.

Var X, N: Integer;
       Sum: Longint;
Begin
    Writeln('Egesz szamokat olvasunk be 0 vegjelig.');
    N:= 0;
    Sum:= 0;
    Repeat
        Write('X= ');
        Readln(X);
        Sum:= Sum+X;
        N:= N+1;
    Until X=0;
    Writeln('A beolvasott szamok atlaga: ', Sum/(N-1):10:2);
End.

Az egész számokat nem szükséges külön-külön tárolnunk, a feladat szempontjából erre nincs szükség, ezért nem alkalmazunk tömböt. A számokat az X nevû változóba fogjuk beolvasni. Mielõtt a ciklust elkezdenénk futtatni, a ciklusban felhasznált változók értékeit beállítjuk (N:= 0; - eddig egyetlen számot sem olvastunk be, Sum:= 0; - a beolvasott számok összege 0).
A ciklusban számoljuk a beolvasott számokat (N), és a számok összegét is (Sum). A ciklus akkor ér véget, amikor 0 kerül beolvasásra. Az átlag számításánál a számok számából el kell venni 1-et, mert a ciklus a 0 beolvasásakor is növelte N értékét, a végjelet pedig általában nem szoktuk a számításnál figyelembe venni.