A programok futását, azt hogy az adatokkal mit csináljon a program, utasításokkal lehet vezérelni. Az egyszerű vagy elemi utasítások - a feldolgozás legkisebb részei - közé az értékadás, az eljáráshívás és az ugrás tartozik. Az egyszerű utasításoktól eltérően a strukturált utasítások segítségével egymásba ágyazott feldolgozási szintek hozhatók létre. Létezik összekapcsoló, with, feltételes és ciklusutasítás.
5.1.1. Értékadás
Egy változónak értékadással adhatunk értéket. Az értékadásban szereplő kifejezés lehet érték, azonosító vagy függvényhívás. Az értékadás operátora a := jel, aminek a jelentése: legyen egyenlő. Az értékadó operátor bal oldalán egy változó áll, jobb oldalán pedig egy kifejezés. Nézzünk néhány példát:
x:=50;
Hki:=H0-dh;
b5:=Sqr(B[i])+x1;
DarabSuly:=mdb;
y:=Hatvany(a5,3);
5.1.2. Eljáráshívás
Egy eljárás (procedure) azonosítója megadásával hívható. Lehet paraméteres vagy paraméter nélküli eljárás. A paraméteres eljáráshíváskor a paramétereket zárójelben kell megadni. Az eljárásoknak a programban általában a hívás előtt kell elhelyezkedni.
Példák:
AdatKiiras;
Keret(2,2,10,5);
5.1.3. A goto utasítás
A programvezérlést átadhatjuk egy - előzőleg a label kulcsszó után definiált - címkére, amelynek az utasítással azonos blokkban kell lennie.
Például:
goto 1; vagy goto Ide;
5.1.4. Az összekapcsoló utasítás
Az összekapcsoló utasítással (a begin és az end kulcsszó-pár) az egy blokkba tartozó utasításokat fogjuk össze.
Például:
procedure AdatKiiras;
begin
GotoXY(5,2);WriteLn(Magassag);
GotoXY(5,4);WriteLn(Szelesseg);
end;
5.1.5. A feltételes utasítások
A feltételes utasításokkal a program feltétel(ek)től függő futása vezérelhető. Ide tartozik az if és a case utasítás.
5.1.5.1. Az if utasítás
Az if (jelentése: ha) feltétele csak igaz vagy hamis eredményt adhat. Többirányú elágazást az if ... then ... else kombinációjával vagy a case utasítással lehet elérni.
Példák:
a) Ha az x értéke kisebb vagy egyenlő 10, mindenképpen vegye fel a 10 értéket:
if x<=10 then x:=10;
b) Ha az x értéke kisebb 10-nél, akkor adjunk hozzá 1-et, más esetben legyen az értéke 10:
A case (jelentése: eset) utasítás egy szelektorból és egy elágazási listából áll. A szelektornak sorszámozott típusúnak kell lennie. Az elágazások közé if-es ág is beépíthető. A case utasításban is lehet else ág, amelyre akkor kerül a vezérlés, ha nem létezik a kifejezésnek megfelelő elágazási út. A case utasítást minden esetben end zárja le. Nagyon jól használható a case utasítás - többek között - menük tételeinek kezelésére.
Példa: az év hónapjainak napszámának meghatározása a HoNap szelektor segítségével történik. Szökőév esetén if-es elágazást alkalmaztunk.
A ciklusok segítségével megismételhető a program meghatározott része. Ide soroljuk a for ... to (downto), a while ... do, a repeat ... until és a with ... do utasításokat.
A repeat ... until típusú ciklus felépítése: ismételd (repeat) a következő programrészt addig (until), amíg a következő feltétel megvalósul. Azaz a program az until kulcsszó után álló feltételt értékeli ki. Az utasítások legalább egyszer lefutnak, és a ciklus addig ismétlődik, amíg a feltétel igaz lesz.
Példák:
a) Addig kérjünk be adatot, míg a beírt érték 1 és 10 közé esik, az ettől eltérő értékeket ne fogadja el.
b) Addig ne történjen semmi, amíg valamelyik (bármelyik) billentyűt le nem nyomjuk.
Az előző ciklusutasítással szemben a while ... do utasítás a ciklus elején vizsgálja a feltételt, s az utasítások csak akkor ismétlődnek, ha a feltétel igaz.
Példa:
A for utasítással numerikus ciklus készíthető, amelyben a ciklusváltozó megadott értékig változik. A ciklusváltozó a to szóval növelhető, a downto szóval csökkenthető.
Példa:
A with utasítás a rekord típusú változók mezőinek egyszerűbb kezelését teszi lehetővé (itt csak jelezzük, hogy az objektum típusnál is használatos). A típusismertetés során közölt példa rekordjaira például a következő módon hivatkozhatunk:
with nélkül:
Ugyanez a with utasítás segítségével:
A programban deklarált eljárások és függvények arra teremtenek lehetőséget, hogy a programunkat logikailag és funkcionálisan meghatározott különálló egységekre bontsuk. Az eljárásokat és a függvényeket a főprogram (vagy egy másik eljárás) vezérli.
Az eljárás deklarálása a procedure kulcsszóval indul, amelyet az azonosító (név) követ. A név után zárójelben paraméter(ek) is megadható(k). Az eljárás szerkezete kicsiben követi a program szerkezetét. Az eljárás feje után a belső (lokális) változók, típusok, konstansok és címkék felsorolása következik (de nem biztos, hogy vannak). Az utasításokat begin és end; között kell felsorolni, minden utasítást logikailag külön sornak tekintve, azaz pontosvesszőt téve a végére (ettől még lehet egy sorba több utasítást írni). A záró end után is pontosvesszőt kell tenni.
a) Példa paraméter nélküli eljárásra (adatbeviteli rutin):
A fenti példában megfigyelhetjük, hogy az egyes adatok bekérése előtt kiírjuk az adat megnevezését (pl. 'Darab neve ='), majd utána kérjük be az adatot (DbNev). A következő adatok esetén hasonlóan járunk el. Adatbeviteli képernyőknél kedvezőbb azonban, hogy először felsoroljuk a bekérendő adatok neveit (ez a célszerűbb, mert látjuk, hogy mely adatokra lesz szükség), ezt követően pedig sorban bekérdezzük az adatokat:
Így viszont az eljárás gyakorlatilag két külön funkcióval rendelkező részre oszlik, amit továbbvihetünk egészen odáig, hogy akár két külön eljárásba is helyezzük a két részt:
b) Példa paraméteres eljárásra:
A következő eljárás a képernyő adott helyére megadott méretű és színösszeállítású egyvonalas keretet rajzol. Ez összesen hat paraméter megadását igényli: a kezdőpont koordinátái (x0, y0), az oszlopok és sorok száma (osz, ssz), valamint az alap és a keret vonalának színe (alapsz, keretsz).
Az eljárás hívása a következő módon történik (a keret a képernyő 2. sorának 5. karakterénél kezdődjön, 20 karakter széles és 6 sor magas legyen; az alapszín piros, a keret színe pedig sárga legyen):
A színek kezeléséről a segédlet további részében még lesz szó.
A függvény abban különbözik az eljárástól, hogy értéket (de csak egy értéket) ad vissza. Deklarálása a function kulcsszóval indul, amelyet az azonosító (név), a paraméterek és az eredmény típusának deklarálása követ. Az utasításblokkban adjuk meg a végrehajtandó utasításokat. A függvényt az azonosítóval kell hívni, a paraméterek típusának és sorrendjének egyeznie kell.
A következő példa tetszőleges kitevőjű hatványozásra alkalmas függvényt mutat be (a Pascal nyelvben csak a négyzetre emelésre van beépített függvény, ez az Sqr).
Használata:
A paraméterekről sok szó esett már korábban. Nézzük meg most, mik is ezek. Paramétereket az eljárások és függvények deklarálásakor adhatunk meg az azonosító (név) mögött, kerek zárójelek között. A paraméterek tulajdonképpen a rutinon belüli lokális változók. A paraméterekre az azonosítókkal hivatkozhatunk. A Turbo Pascal három paramétertípust különböztet meg:
Ha egy paramétert csak az azonosítójával adunk meg, akkor értékparaméterről beszélünk. Ha a paraméter előtt a var kulcsszó áll, és a paramétert típusdeklaráció is követi, akkor változó paraméterről van szó. Ha a var után nem áll típusdeklaráció, akkor típus nélküli a paraméter.
A jegyzet elejére A fejezet elejére A 6. fejezetre
if x < 10
then x:=x+1
else x:=10; case HoNap of
1,3,5,7,8,10,12: NapSzam:=31;
4,6,9,11: Napszam:=30;
2: if SzokoEv then Napszam:= 29
else Napszam:=28;
end; repeat
WriteLn('Irj be egy szamot');
ReadLn(x);
until
(x>=1) and (x<=10); repeat until KeyPressed;
while x<=10 do
begin
osszeg:=osszeg+x;
WriteLn('Összeg=',osszeg);
end; for i=1 to 10 do
begin
osszeg:=osszeg+x[i];
WriteLn('Összeg=',osszeg);
end; ReadLn(Hallgato.VezNev);
ReadLn(Hallgato.KerNev);
ReadLn(Hallgato.TanKor);
ReadLn(Hallgato.TanAtlag); with Hallgato do begin
ReadLn(VezNev);
ReadLn(KerNev);
ReadLn(TanKor);
ReadLn(TanAtlag);
end; procedure EljarasNev(parameter);
lokális címkék,
konstansok,
változók,
típusok
begin
Utasítások;
end; procedure AdatBe;
begin
ClrScr;
GotoXY(2,2);WriteLn('Darab neve = ');
GotoXY(20,2);ReadLn(DbNev);
GotoXY(2,4);WriteLn('Darabmagassag =');
GotoXY(20,4);ReadLn(Hdarab);
GotoXY(2,6);WriteLn('Darabhosszusag =');
GotoXY(20,6);ReadLn(Ldarab);
GotoXY(2,8);WriteLn('Homerseklet =');
GotoXY(20,8);ReadLn(Tdarab);
end;{--AdatBe---------} procedure AdatBe;
begin
ClrScr;
GotoXY(2,2);WriteLn('Darab neve = ');
GotoXY(2,4);WriteLn('Darabmagassag =');
GotoXY(2,6);WriteLn('Darabhosszusag =');
GotoXY(2,8);WriteLn('Homerseklet =');
GotoXY(20,2);ReadLn(DbNev);
GotoXY(20,4);ReadLn(Hdarab);
GotoXY(20,6);ReadLn(Ldarab);
GotoXY(20,8);ReadLn(Tdarab);
end;{--AdatBe---------} procedure Kiiras;
begin
ClrScr;
GotoXY(2,2);WriteLn('Darab neve = ');
GotoXY(2,4);WriteLn('Darabmagassag =');
GotoXY(2,6);WriteLn('Darabhosszusag =');
GotoXY(2,8);WriteLn('Homerseklet =');
end;{--Kiiras---------}
procedure AdatBe1;
begin
GotoXY(20,2);ReadLn(DbNev);
GotoXY(20,4);ReadLn(Hdarab);
GotoXY(20,6);ReadLn(Ldarab);
GotoXY(20,8);ReadLn(Tdarab);
end;{--AdatBe1--------} Procedure Keret (x0,y0,osz,ssz,alapsz,keretsz:integer);
var o,r,s:integer;
begin
TextBackGround(alapsz);
TextColor(keretsz);
GotoXY(x0,y0);Write(#218);
for o:=1 to osz do Write(#196);
Write(#191);
for s:1 to ssz+1 do begin
GotoXY(x0,x0+s);Write(#179);
for r:=1 to osz do Write(' ');
GotoXY(x0+osz+1,y0+s);Write(#179);
end;
s:=s+ssz;
GotoXY(x0,x0+ssz+1);Write(#192);
for o:=1 to osz do Write(#179);
Write(#217);
end; Keret(5,2,20,6,4,14);
function Hatvany(alap,kitevo:real):real;
begin
hatvany:=exp(kitevo*ln(alap));
end;
Eredmeny:=2.85*hatvany(szam,4);
Dr. Szabó László: A Pascal programnyelv
Miskolc, 1997 © Szabó László