Pascal I.      Pascal II.      Delphi       Linkek     
Pascal I.
01. A program szerkez...
01. Gyakorló feladatok
02. Változók használata
02. Gyakorló feladatok
03. A FOR ciklus
03. Gyakorló feladatok
04. Egymásba ágyazo...
04. Gyakorló feladatok
05. Karakterláncok ...
05. Gyakorló feladatok
06. Az IF feltételvizsgálat
06. Gyakorló feladatok
07. A CASE elágazás
07. Gyakorló feladatok
08. A WHILE..DO ciklus
08. Gyakorló feladatok
09. A REPEAT..UNTIL ...
09. Gyakorló feladatok
10. Tömbök (ARRAY ...
10. Gyakorló feladatok
11. Műveletek tömbökkel
11. Gyakorló feladatok
12. Kétdimenziós töm...
12. Gyakorló feladatok
13. Műveletek kétdime...
13. Gyakorló feladatok

     
4 Egymásba ágyazott ciklusok
   
  • egymásba ágyazott ciklusok

  • csökkenő ciklusváltozó (TO helyett DOWNTO)

      
     4.1 Egymásba ágyazott ciklusok

     Programjaink készítésekor sokszor elő fog fordulni, hogy nem lesz elég egy ciklust használnunk, hanem vagy egymás után, vagy akár egymáson belül fogunk több ciklust használni. Lássunk most az utóbbi esetre egy példát. Mielőtt azonban belekezdenénk, készítsük egy egyszerűbb programot, melyben még csak egy ciklusunk lesz.

Feladat: Készítsünk programot, amely beolvas egy egész számot, majd kiír a képernyőre egymás mellé ennyi darab * (csillag) karaktert.

Megoldás: A programban deklarálni fogunk egy n (integer típusú) változót, melybe beolvassuk a program elején a kiírandó csillagok számát. Ezen kívül szükségünk lesz még egy ciklusváltozóra is - ez legyen i. Magában a programban egy egyszerű write('*') parancsot fogunk megismételtetni n-szer egy for ciklus segítségével (a ciklus most 1-től n-ig fog menni). Programunk így néz ki:

program Pelda14a;
var n,i:integer;
begin
 write('Kerem a kiirando csillagok szamat: ');
 readln(n);

 for i:=1 to n do write('*');
end.

Miután lefuttattuk a programot, a következő jelent meg a képernyőn:

Kerem a kiirando csillagok szamat: 8
********_

     Módosítsunk most a fenti programon úgy, hogy ne csak egy sornyi csillagot írjon ki, hanem a csillagok segítségével rajzoljon ki egy négyzetet. Például n=8 esetre a következő jelenjen meg a képernyőn:

     ********
     ********
     ********
     ********
     ********
     ********
     ********
     ********

     Tehát ne csak egy sorba írjon ki n drb. csillagot, hanem írjon ki n darab sort, melyek mindegyikében n darab csillag legyen. Ezt úgy érhetjük el, hogy a fenti programban levő ciklus után (amely kiír egy sornyi csillagot) teszünk egy writeln utasítást (ezzel a kiírt sor után egy új sorba kerülünk), majd a sor kiírására szolgáló ciklust az utána következő writeln paranccsal együtt (begin..end kulcsszavakkal összekapcsolva) megismételjük n-szer (egy külső ciklusban). Programunk így néz ki:

program Pelda14b;
var n,i,j:integer;
begin
 write('Kerem a kiirando csillagok szamat: ');
 readln(n);
 for j:=1 to n do
  begin

  for i:=1 to n do write('*');
  writeln;
  end;

end.

     A program a következőt fogja kiírni a képernyőre:

Kerem a kiirando csillagok szamat: 8
********
********
********
********
********
********
********
********
_

     Fontos, hogy ha ilyen és ehhez hasonló egymásba ágyazott ciklusokat használunk, akkor a külső ciklusnak egy másik ciklusváltozót kell választanunk, mint a belső ciklusnak. A mi példánkban a külső ciklus ciklusváltozója j, a belső ciklusé pedig i. A két ciklus valójában a következő képen fut le:

  • a külső ciklusnál a j kezdeti értéke 1 lesz (j=1),
      
    - a belső ciklusnál az
    i kezdeti értéke 1 lesz (i=1), majd végrehajtódik a write('*') parancs,
    - a belső ciklusnál az i értéke növekszik (i=2), majd végrehajtódik a write('*') parancs,
    - ...
    - a belső ciklusnál az i értéke növekszik (i=n), majd végrehajtódik a write('*') parancs,
       
    - a
    writeln parancs lefutásával a kurzor egy új sorba kerül,
       

  • a külső ciklusnál a j értéke növekszik (j=2),
       
    - a belső ciklusnál az
    i kezdeti értéke 1 lesz (i=1), majd végrehajtódik a write('*') parancs,
    - a belső ciklusnál az i értéke növekszik (i=2), majd végrehajtódik a write('*') parancs,
    - ...
    - a belső ciklusnál az i értéke növekszik (i=n), majd végrehajtódik a write('*') parancs,
       
    - a
    writeln parancs lefutásával a kurzor egy új sorba kerül,
       

  • a külső ciklusnál a j értéke növekszik (j=3),
       
    - a belső ciklusnál az
    i kezdeti értéke 1 lesz (i=1), majd végrehajtódik a write('*') parancs,
    - a belső ciklusnál az i értéke növekszik (i=2), majd végrehajtódik a write('*') parancs,
    - ...
    - a belső ciklusnál az i értéke növekszik (i=n), majd végrehajtódik a write('*') parancs,
       
    - a
    writeln parancs lefutásával a kurzor egy új sorba kerül,
       

  • ...

     Ez így folytatódik mindaddig, amíg a külső ciklus ciklusváltozója (j) nem éri el az n értékét, majd ezen belül a belső ciklus ciklusváltozója (i) is nem éri el az n értékét.

     Ebből is látszódik, hogy ha a két ciklusban ugyanaz a ciklusváltozó lenne (pl. mindkettőben i), akkor a belső ciklus változtatná a külső ciklus által beállított értéket, ami hibához vezetne.


     4.2 Csökkenő ciklusváltozó (TO helyett DOWNTO)

     Néha előfordulhat, hogy olyan ciklusra van szükségünk, melyben a ciklusváltozó nem növekszik (pl. 1-től 10-ig), hanem csökken (pl. 10-től 1-ig). Ilyenkor egyszerűen a to helyett a downto-t fogjuk használni:

for ciklusváltozó := kifejezés1 downto kifejezés2 do utasítás ;

     Ebben az esetben ciklusváltozó felveszi először a kifejezés1 értékét. Végrehajtja az utasítás-t, majd a ciklusváltozó csökken eggyel és ismét végrehajtja az utasítás-t. Ezután ismét csökken eggyel és végrehajtja az utasítás-t. Mindezt addig fogja csinálni, amíg a ciklusváltozó nem lesz egyenlő a kifejezés2 értékével. Ekkor még utoljára végrehajtja az utasítást.

     Ha a kifejezés2 értéke nagyobb, mint a kifejezés1 értéke, akkor az utasítást egyszer sem hajtja végre.

     Ha a kifejezés1 értéke egyenlő a kifejezés2 értékével, akkor az utasítást csak egyszer hajtja végre.

Feladat: Készítsünk programot, amely bekér egy N természetes számot, majd kihagy egy üres sort, és kiírja egymás mellé N-től 0-ig az összes egész számokat (mindegyik szám után egy szóközt rak).

Megoldás: Mivel a számokat csökkenő sorrendben kell kiírnunk, ezért a ciklusban a fent említett downto-t fogjuk használni:

program Pelda15;
var i,n:integer;
begin
 write('Kerem az N szamot: ');
 readln(n);
 writeln;
 for i:=n downto 0 do write(i,' ');
end.

Lássuk mit írt ki a programunk, ha a program futásakor az N számnak 15-öt írunk be:

Kerem az N szamot: 15

15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 _

Próbáljuk programunkat lefuttatni többször is, mindig az N-nek más számot megadva. Hogy a következő futtatásnál ne a 0 után kezdődjön a kiírás a képernyőre, kiegészíthetjük ezt a programot még úgy, hogy a végére a ciklus után beírunk egy writeln; parancsot (esetleg kettőt, ha szeretnénk hogy programunk után egy üres sort is kihagyjon).
   

     

(C) 2004-2013, PaedDr. Végh Ladislav, Komárno, Szlovákia