Most a nyári szünet miatt
gondoltam, hogy nem megyek tovább a Pascal nyelv rejtelmeibe,
hanem egy rövid kis összefoglalót írok az
eddig megismert dolgokról egy kicsit más
nézőpontban. Szóval, ezen
cikkünkben a Pascal nyelv utasításait fogjuk megvizsgálni egy kicsit közelebbről.
Na lássunk neki!
Ezeket az utasításokat két nagy csoportra
oszthatjuk: egyszerű és strukturált.
Nézzük először az egyszerű
utasításokat. Hát (háttal nem
kezdünk mondatot), bizony, ezek a következők: az értékadó utasítás, a goto utasítás és az eljáráshívás.
Na részletezzük ezeket egy kicsit:
-
Értékadás: Legalapvetőbb
utasítás ez (Ki gondolná?), hisz már
beszéltünk a változókról,
és ezeknek bizony értékeket kell adni,
bármilyen meglepő is. Bár erről
már volt szó, azért még egyszer leírom. Ez az utasítás két részből áll:
jobb és bal oldalból, a kettőt a := jel választja el egymástól. A jobb
oldalon természetesen csak változó állhat, a bal oldalon lehet konstans,
változó vagy kifejezés. Pl.:
x:=3.5; { konstans
}
y:=w; { változó }
z:=x*y+sqr(x); { kifejezés
}
-
Goto: Na,
szóval, ez az az utasítás amit ne
használjatok, mert az nem szép! Bármennyire
is szükség lenne rá, a Pascalban szinte mindig el lehet kerülni a goto
utasítás használatát. Akkor
szép egy strukturált program - egy Pascal program
- felépítése, ha nem tartalmaz goto utasítást, amely a programot
áttekinthetetlenné teszi.
-
Eljáráshívás: Azt
hiszem pont ezzel foglalkoztam legutóbbi cikkemben. Remélem tudjátok!
Ezek voltak az
egyszerű(bb) utasítások. Azért a
strukturáltak nem lesznek ilyen egyszerűek. (Ezt
muszáj volt leszögeznem, mielőtt még azt
hinnétek, hogy csak ennyi az egész, és nem
olvassátok tovább. És ha ez így lenne,
akkor én teljesen feleslegesen
öltem bele a hétfő estémet abba, hogy ti okosodjatok egy kicsit, pedig
jobb dolgom is lett volna!) A kis kitérő után térjünk vissza a strukturált
utasításokhoz. A könnyebb felfogás érdekében prezentálok néhány folyamatábrát
is. Ezekkel segítséget nyújthatok az utasítások szerkezetének teljes átlátásához.
Felsorolás szintjén: a blokk utasítás, a feltételes utasítások (if,
case), a ciklusok (for, while, repeat-until) és a with
utasítás. Részletesebben:
-
Blokk:
A begin és end
kulcsszavak közötti utasítások
sorozatát összetett utasításnak,
blokknak nevezzük. Azon Pascal utasítások esetén, amelyek
csak egy utasítást tudnak végrehajtani, fontos az egynél több utasítás
összefogása egyetlen utasítássá a begin és end
használatával.
-
A feltételes
utasítások
segítségével a programban lehetőség
van bizonyos feltételek teljesülése
esetén egy utasítás vagy egy programrészlet végrehajtására. Ezek az utasítások
elágazásokat biztosítanak a programban. Ezen elágazásoknak két fajtája
van: az if és a case.
-
Az if
utasítás kétirányú,
feltételes utasítást hajt végre. Általános formája:
if logikai kifejezés then
utasítás1
else utasítás2;
Az if után
logikai változó vagy logikai kifejezés állhat, amelynek
teljesülésétől függ, hogy melyik utasítás kerül végrehajtásra. Ha a feltétel igaz (true),
akkor a then utáni utasítás1 fog
végrehajtódni, ha a feltétel
hamis (false), akkor az else utáni utasítás2 kerül
végrehajtásra. Az if szerkezetet a ;
zárja le, ezért az else elé nem szabad kirakni. Ha a then vagy az else után egynél több
utasítást akarunk végrehajtatni, akkor azt a korábban ismertetett
módon foglaljuk egy blokk utasításba a begin és az end
segítségével.
Egy példa az if-then-else
szerkezetre:
if X<Y then Min:=X
else if X=Y then Min:=X
else Min:=Y;
Az utasítás
folyamatábrája:

Az if utasításnak egy
egyszerűbb formája is használható, ha egy utasítást csak egy feltételtől
függően végre akarunk hajtani, vagy át akarunk ugrani. Ez esetben így fest:
if logikai kifelyezés then
utasítás1;
Egy példa az if-then
szerkezetre:
if Old=New then begin
WriteLn('A régit írtad: ',Old);
Write('Írj be újat : ');
ReadLn(New);
end;
A
folyamatábra:

-
A case
utasítással többirányú elágazást hozhatunk létre a programunkban. A case
utasítás tartalmaz a case kulcsszó után álló szelektort,
amelyet az
of kulcsszó
zár. Ezt követi egy vagy több ún. case konstans
és a hozzá tartozó
utasítások és végül nem kötelezően egy else
ág. A case utasítást az end zárja.
Általános formája:
case szelektor of
cimke1: utasítás1;
...
cimken:
utasításn;
else
utasításm;
end;
A szelektor csak sorszámozott típusú lehet. Ezek a következők: integer, shortint, longint,
byte, word, boolean, char. A case konstansok (címke)
típusának meg
kell egyeznie a szelektor típusával (azt hiszem ez
természetes). Azon utasítás vagy utasítások kerülnek végrehajtásra, amelynek a címkéje
megegyezik a szelektor értékével, ha nincs ilyen címke, az
else utáni utasítás kerül
végrehajtásra. Természetesen a
több utasítást
tegyük begin és end közé, vagyis egy blokkba, ha ezt még mindig nem tanultátok
volna meg. Többször nem óhajtom megismételni.
Egy példa a case szerkezetre:
case Jegy of
1:
WriteLn('Elégtelen');
2:
WriteLn('Elégséges');
3:
WriteLn('Közepes');
4:
WriteLn('Jó');
5: WriteLn('Jeles');
else WriteLn('Ilyen
jegy nincs!');
end;
Az
utasítás
folyamatábrája:

-
Ciklusok: A programban gyakran van
szükség utasítások ismételt
végrehajtására. Az ilyen feladatok
megoldására szolgálnak a ciklusok. A Pascalban három féle ciklus található:
a for, a while és a repeat-until.
-
A
for ciklusutasítást akkor használjuk,
ha pontosan ismerjük az ismétlések
darabszámát. A for ciklust két féle képen lehet használni: növekvő vagy csökkenő ciklusként.
A for ciklusutasítás csak egyetlen utasítás végrehajtására vonatkozik (ha
több utasítás, akkor blokk).
A for utasítás alakja
növekvő ciklus esetén: kezdőérték < végérték
for
ciklusváltozó:=kezdőértékto
végérték do utasítás;
A for
utasítás alakja csökkenő ciklus
esetén:
kezdőérték > végérték
for
ciklusváltozó:=kezdőértékdownto végérték do utasítás;
Egy rövid
példa a for használatára:
for Szam:=1 to 20 do Osszeg:=Osszeg+Szam;
A folyamatábra:
-
A while
utasítás tartalmaz egy logikai kifejezést, amely vezérli az
ismételt utasítások végrehajtását.
Az
utasítás általános formája:
while logikai kifejezés do
utasítás;
Ennél a ciklusfajtánál
a logikai kifejezés a
ciklusmag végrehajtása előtt kerül
kiértékelésre.
Ha az hamis, akkor a ciklus egyszer sem kerül végrehajtásra. Ezért ezt
a logikai
kifejezést belépési feltételnek
is hívjuk. Az egyetlen
utasításból
álló ciklusmag (ha több utasítás, akkor blokk) addig kerül végrehajtásra,
amíg a logikai kifejezés igaz.
Példa a while
ciklus használatára (más megoldás az előzőre):
while Szam < 21 do begin
Osszeg:=Osszeg+Szam;
Szam:=Szam+1;
end;
A
folyamatábra:
-
A repeat-until ciklus hasonló a while ciklushoz. Az ismétlést itt is egy logikai
kifejezés vezérli. A
különbség az, hogy a repeat-until ciklus egyszer mindenképpen
végrehajtódik, mert a feltétel (a
logikai kifejezés)a ciklus végén
kerül kiértékelésre. A ciklusmag addig hajtódik végre, amíg
a logikai kifejezés hamis, és akkor fejeződik be, amikor a logikai kifejezés
igazzá válik. Ebben az esetben a logikai kifejezést kilépési feltételnek
hívjuk.
Az utasítás
általános formája:
repeat ciklusmag; until logikai kifejezés;
A
ciklusmag több utasításból is állhat. Itt nincs szükség a begin-end kulcsszavak
használatára, mert a repeat-until kulcsszavak helyettesítik azokat.
Még mindig ugyanaz a példa:
repeat
Osszeg:=Osszeg+Szam;
Szam:=Szam+1;
until Szam=21;
Az
utasítás
folyamatábrája:

-
A with utasítással
egyszerűbben adhatunk rekordnak értéket, mivel a rekord mezőire, mint egyedül
álló változókra hivatkozhatunk. Általános formája:
with rekord_változó
doutasítás;
Annyival
rövidebb
egy rekord megadási módja, hogy a with után megadott rekord_változó
nevét és a pontot a do
után nem kell újra kiírni, hanem elegendő
csak a mező neveit megadni.
Na ezekről
körülbelül ennyit kéne tudni (azért
lehet többet is). Majd megpróbálok összekapni
néhány példaprogramocskát, amit természetesen felrakunk a lemezmellékletre.
Azért még ne tegyétek le
az újságot, mert még egyenlőre én se
fejeztem be. Van itt valami, amiről - bevallom
töredelmesen - én még eddig nem tudtam. De ez nem olyan nagy tragédia,
mint ahogy az sem, hogy eddig nem írtam le nektek, mert részben a deklarációs
részhez, részben pedig ide kapcsolódik. Ez a valami pedig a következő lenne:
a rekord (mint adattípus) és a case
összekapcsolása. Ebből lesz a variálható rekord (és nem a cserebogár). Lássunk neki!
Variálható rekordnak nevezzük azt a
rekordot, amelynek mezőadataihoz valamilyen
tulajdonságtól függően más és
más adatok tartoznak. Példaként
nézzük meg, hogy egy könyvtárban a
könyveket milyen adatok szerint tarthatjuk nyilván.
Hát, nyilván a könyvnek
van egykét szerzője, van címe, van kiadója, van kiadási éve, van oldalszáma
és van leltári száma. A könyv tulajdonságát határozza meg az a tény, hogy
kikölcsönözhető-e. A könyv csak akkor kölcsönözhető, ha a raktárban van.
Ebben az esetben az ottani helyét tartjuk nyilván. Ha a könyv nincs a raktárban,
akkor valószínűleg ki van kölcsönözve. Ilyenkor a kikölcsönző személy adatait
rendeljük a könyv adataihoz. Tehát a deklaráció:
var
Konyv: record
Szerzok : String;
Cim : String[50];
Kiado : String[30];
Ev : Integer;
Oldalak : 1..1000;
Leltar : 1..10000;
case Kiveheto: Boolean of
True : (Hely: record
Emelet :
1..4;
Sor : 1..15;
Polc : 1..50;
end);
False : (Olvaso: record
Nev : String[30];
Lakcim : String[40];
Tel : String[15];
Lejar : String;
end);
end;
end;
Azt hiszem, most már tényleg befejeztem. Na nem
örökre, mert a következő számban újabb érdekességekkel folytatom ezen cikksorozatomat. Addig is
böngésszétek a lemezújságot, és ha valami probléma van írjatok!
Magician
|