A Pascal programokban szereplő adattípusokról és szerkezetekről

Ez a dokumentáció azokról az adattípusokról és programozási szerkezetekről szól, amelyek a programraktárban lévő Pascal programokban előfordulnak, de az iskolai Pascal-ismeretekkel nem biztos, hogy érthetőek. Azonban a Pascalt jobban ismerőknek, és főleg a programraktár bővítőinek sem árt átfutni, hogy lássák a programraktár deklarációinak és adattípusainak a koncepcióját.

Eljárások, függvények

Az eljárás előre elkészített utasítássorozat, amelyet deklarálása után a programból meghívhatunk, azaz végrehajthatunk. A program deklarációs részében kell definiálni, ott, ahol a típusokat, konstansokat, változókat stb. A definíció a következő részekből áll:

procedure eljárásnév(formális paraméterlista);
  deklarációk, mint a főprogramban
begin
  utasítások, mint a főprogramban
end;

Az eljárásban ugyanúgy deklarálhatunk változókat (ún. lokális változókat), címkéket, stb. mint a főprogramban (bár típusokat és konstansokat ritkán szoktunk), de ezeket csak az eljáráson belül érhetjük el. Ha az eljáráson belül és a főprogramban ugyanolyan nevű azonosító van, az eljáráson belülit tudjuk elérni. Az eljárás deklarációs részében akár másik eljárást is definiálhatunk, ilyenkor ezt is csak az eljárásból tudjuk hívni. (Ilyet akkor célszerű írni, ha meg akarjuk előzni, hogy a csak a külső eljárásban használt eljárás neve ütközzön egy tőle függetlenül deklarált azonosítóval, és a használt eljárást úgyis csak "belső használatra" szánják.) Egy eljárásban deklarált azonosító az eljárásból hívott másik eljárásban nem érhető el, kivéve, ha azt ennek az eljárásnak a deklarációs részében, a kérdéses azonosító után deklarálták.

Az eljárásnak át lehet adni adatokat, amelyek a működését meghatározzák. Hogy egy eljárás milyen paramétereket vár, meg kell adni zárójelek között, a formális paraméterlistában. Ezek szintén lokális változók, amiknek a kezdeti értékét a hívó program állítja be. A paramétereket pontosvesszővel kell egymástól elválasztani, minden paraméternek meg kell adni a nevét, és : után a típusát. A : előtt vesszővel elválasztva több nevet, is megadhatunk, ez több azonos típusú paramétert jelent. Pl. a
procedure example_proc(S:string; i1,i2:integer);
fejlécű eljárásnak egy string és két integer típusú paramétere van. Ha nincs paraméter, a zárójelek elhagyhatók.

Egy eljárást úgy hívhatunk meg, hogy megadjuk a nevét, majd, ha vannak, zárójelek között, vesszővel elválasztva a paramétereit. Pl. az előbbi eljárás lehetséges hívása:
example_proc('Hello, world',1,3);

Az eddig bemutatott paraméterátadási mód, az érték szerinti paraméterátadás esetén a paraméter minden szempontból lokális változó lesz, így ha az eljáráson belül megváltoztatjuk, az a hívó programra semmilyen közvetlen hatással nincs. Létezik viszont egy olyan paraméterátadási mód, ahol paraméternek kötelezően változót kell megadni, és a formális paraméterlistában megadott név csak a külső változó "álneve" lesz, annak eljáráson belüli módosításai a hívó környezetben is megváltoztatják a változó értékét. Azt, hogy egy eljárás ilyen "cím szerinti paramétert" vár, a formális paraméterlistában a paraméter neve előtti var kulcsszóval lehet jelezni. Ez a legközelebbi pontosvesszőig hat ki, tehát egy paraméterre, vagy vesszővel elválasztott paraméterek csoportjára.Pl. a
procedure example_proc(var S:string; i1,i2:integer);
fejlécű eljárásnak az első paramétere lesz cím szerint átadott.

Szükség lehet arra, hogy egy ilyen utasítássorozat kiszámítson valamilyen adatot, és visszaadja azt a főprogramnak. Ilyenkor eljárás helyett függvényt kell írni (procedure helyett function kulcsszó), és megadni a visszaadott érték típusát. A függvény fejléce:
function függvénynév(formális paraméterlista):visszatérési típus;
A paraméterlista és a függvény többi része az eljárással azonos felépítésű.

A függvény hívásakor szintén a nevét és a paramétereit kell megadni, de nem önmagában, hanem egy kifejezésben lehet használni, pl. a visszaadott értéket elraktározhatjuk egy változóban:
v:=example_func(5);
, ha a függvénynek egytlen, szám típusú paramétere van.

Ha egy szubrutinból több adatot kell visszaadni, arra több lehetséges megoldás van:

Ha azonos típusúak, tömböt adni vissza. array tartomány of típus szerkezetet azonban nem lehet visszatérési típusnak megadni, hanem deklarálni kell őket, ami viszont a programraktárban ütközéseket, vagy ugyanannak a típusnak különböző nevekkel való fölösleges deklarálását eredményezhetne, és Turbo Pascalban nem működik, ezért nem is használjuk.
Különböző típusok esetén rekordokat lehetne használni, de ezt az előbbi okból nem használjuk.
Cím szerinti paraméterekkel. Ez a legegyszerűbb megoldás: az eljárás a paraméterbe teszi a visszaadandó értéket.
Mutatók, illetve dinamikus tömbök használatával.

A programraktárban változó szerinti paramétereket, ill. tömbök esetén mutatókat, dinamikus tömböket használunk.

Típusok

Rekordok

Rekordokra bonyulultabb adattárolási szerkezeteknél (pl. láncolt listáknál) van szükség. Ezek olyan típusok, amelyekkel egyetlen változóban (vagy tömbelemben) tárolhatunk meghatározott számú, különböző típusú adatot ("mezőt"). Egy rekord típus deklarációja (amit a : után, de inkább a type deklarációban kell írni):

record
  mezőnév1,mezőnév2,...:típus;
  mezőnév1,mezőnév2,...:típus2;
  ...
end;

Mutatók

A számítógép memóriájában minden bájtnak van egy (általában 32 bites) címe. A mutató típusú változóban ilyen címet tárolhatunk.

Az egész memóriának azonban mindig csak egy része van lefoglalva a programunk számára, a többi része szabad, vagy más programok használják. A program a következő módokon használhat memóriát:

A program indításától véget éréséig folyamatosan lefoglalt és használatban lévő részek: ilyenek a magát a program gépi kódját tartalmazó részek (de ez a program írásakor nem lényeges), valamint a globális, tehát a főprogram deklarációs részében deklarált változókat tartalmazó memóriaszegmens (adatszegmens). Ezek korlátozott méretűek, Turbo Pascalban a maximum 64 KB.
A program futása közben, a veremszegmensben tárolt részek: a veremszegmens is a program indításakor kerül lefoglalásra, tehát a program számára van fenntartva, de mindig csak egy részét használjuk. Itt az eljárások és a függvények lokális változói, érték szerinti paraméterei, cím szerint átadott paraméterek memóriacímei, és az eljáráshívásokkor eltárolt "visszatérési címek", amik azt jelzik, hogy a meghívott eljárás befejezése után hol kell folytatni a hívó programot. Ez is hasonlóan korlátozott méretű, tipikusan Turbo Pascalban 16-64 KB (64 a maximum), Free Pascalban 128 KB.
"Kézi" lefoglalással, azaz a program egy megfelelő parancs meghívásával memóriát kér.

Egy mutató típusú változó tartalmazhat:

Nulla értéket, ami azt jelenti, hogy a változó "nem mutat sehová". Ezt mi magunk használhatjuk pl. egy láncolt lista végének jelzésére ("nincs következő elem, ahova mutatni kéne").
A program által lefoglalt, "legálisan használható" memóriacímet. Természetesen a címtől indulva csak annyi memóriát érhetünk el hiba nélkül, amennyit lefoglaltunk.
A program számára nem lefoglalt, vagy ismeretlen memóriacímet. Ha egy memóriacímbe még nem kértünk memóriát és nem helyeztük bele egy lefoglalt memóriára mutató címet, vagy azt a memóriát, amelyre mutatott, már felszabadítottuk, a cím által mutatott adat lekérdezése általában programhibát eredményez.

A mutató deklarációkor meg kell adni, hogy milyen típusú adatra mutathat (ez röviden a mutató típusa). Adott típusú mutató deklarálásakor így kell a típust megadni: ^típus.

Ha egy mutató (mondjuk, p) érvényes memóriacímet tartalmaz, a mutatott adatot így kérdezhetjük le: p^.

Egy mutatóba a következő módokon kerülhet érvényes memóriacím:

Egy változó címének belehelyezésével: a @ operátort használhatjuk egy változó címének lekérdezéséhez. Pl.:
p:=@v;
, ha p olyan típusú mutató, mint a v változó típusa. Ez után p^ egyenértékű v-vel. Mivel azonos memóriaterületet jelölnek, ha bármelyiket módosítjuk, az a másikat is módosítja. Lokális változó címét csak lokálisan használt mutatóba tegyük, mert a szubrutin végén a memória felszabadul.
Memória lefoglalása egy adat számára a new paranccsal: paramétere egy mutatóba lefoglal annyi memóriát, amennyi a mutató típusa által meghatározott egy darab adathoz kell. Pl. a következő művelet után:
new(p);
p^-t a mutató deklarációjakor megadott típusú változóként használhatjuk. Amikor már nincs szükség rá, az így lefoglalt memóriát a dispose paranccsal fel kell szabadítani:
dispose(p);
Adott mennyiségű memória lefoglalása a getmem paranccsal: pl. a
getmem(p,8);
parancs 8 bájt memóriát foglal le, és az első bájt címét elhelyezi a mutatóban. Az így lefoglalt memória felhasználásáról később lesz szó. A parancs szempontjából a mutató típusának nincs jelentősége, a lefoglalandó memória méretét bájtokban kell megadni. A sizeof beépített függvénnyel lekérdezhetjük egy típus vagy egy változó méretét bájtokban, pl. sizeof(longint), és ha v longint típusú változó, akkor sizeof(v) is 4-et ad. Hogy később esetleg egyszerűbb legyen megváltoztatni a típust, és mert egy típus mérete számítógépgéptípustól is függhet, általában így foglalunk le memóriát:
getmem(p,n*sizeof(p^));
, ahol n az, ahány adatot tárolni akarunk. Ez hibásnak tűnhet, hiszen a memóriakéréskor a mutató még nem tartalmaz érvényes memóriacímet, de a sizeof nyelvi szerkezet, a méret meghatározásához nincs szükség a változó aktuális tartalmára, csak típusára, ezért nem okoz hibát. Az így lefoglalt memóriát a freemem paranccsal kell felszabadítani:
freemem(p,n*sizeof(p^));
A freemem második paraméterében ugyanazt a méretet kell megadni, mint lefoglaláskor.

Mutatók használata dinamikus tömbök létrehozásához

Sokszor előfordul olyan eset, hogy egy algoritmus adatok listáján dolgozik. Hogy mennyi adaton, az csak az adott szubrutint használó programban dől el, illetve sokszor csak a program futása közben, hiszen egy jó programnál a felhasználó mondja meg, hogy mennyi adaton dolgozzon. Ezért nem használunk statikus tömböket, ahol a tömb méretét előre meg kell adni. A Free Pascal rendelkezik beépített dinamikus tömb támogatással, de a Turbo Pascal nem, ezért a Turbo Pascal programokban mutatókat használunk dinamikus tömbök létrehozására. Amikor a program megtudja, mennyi adatot fog tartalmazni a tömb, egy mutatóba a getmem paranccsal lefoglal ennek megfelelő mennyiségű memóriát, és mikor már nincs szükség az adatokra, felszabadítja. Az elemeket egy "trükkel" érhetjük el: a mutatót egésszé konvertáljuk, mégpedig longint-té, mert DOS-ban annak a mérete egyezik meg a mutatóéval, hozzáadunk annyit, hogy, mint mutató, a kívánt sorszámú elemre mutasson, és visszakonvertáljuk mutatóvá. Típusok között így konvertálhatunk: céltípus(konvertálandó érték). Mutatóvá való konverzióhoz azonban deklarálni kell a mutató típusát, ezért tegyük fel, hogy a pword típust deklaráltuk, mint ^word (kétbájtos, előjel nélküli egyész mutatója). Ekkor az ilyenekből álló p tömb i. elemének elérése: pword(longint(p)+i*sizeof(p^))^, ha az elemeket 0-tól számozzuk. Ezt a módszert azonban csak Turbo Pascalban használjuk, esetlegessége abban rejlik, hogy ha a deklarációnál megváltoztatjuk az adattípust (pl. 2 bájtos helyett 4 bájtosra), akkor minden elemelérésnél meg kell változtatni, és hogy más operációs rendszeren és géptípuson nem garantált, hogy a longint mérete megegyezik a mutató méretével.

Dinamikus tömbök a Free Pascalban

A Free Pascal (az 1.1-es verziótól) beépített dinamikus tömb támogatással rendelkezik. Dinamikus tömb deklarációja: array of elemtípus. A tömb elemeit ugyanúgy érhetjük el, mint egy 0-tól számozott statikus tömb elemeit. Mielőtt a tömböt használjuk, meg kell adnunk az elemszámát a setlength paranccsal: a következő deklaráció után:
var a:array of word;
, a begin és az end között, az utasításblokkban megadjuk a méretét:
setlength(a,100);
Ez lefoglalja a memóriát 100 db word típusú elem számára. A méretet bármikor változtathatjuk. Ha növeljük, az elemek megmaradnak, ha csökkentjük, az utolsó elemek elvesznek. Ez azonban lassú folyamat, mert a gép összes elemet átmásolja az új méretű tömbbe, és a réginek lefoglalt memóriát felszabadítja. Ha a tömböt már nem használjuk, felszabadítjuk a lefoglalt memóriát:
finalize(a);
Ez ekvivalens a következő hívással:
setlength(a,0);

A dinamikus tömb elemszámát a length(a) függvényhívással kérdezhetjük le.

Ha Free Pascalban dinamikus tömböt akarunk átadni paraméterként, vagy visszaadni függvényértékként, annak típusát deklarálni kell, és a deklarált típusnevet kell használni. Az egységesség és az ütközések elkerülése erdekében a Pascal beépített típusainak esetében a deklarációt a types modulba kell helyezni, speciális típus esetén pedig abba, amelyben a típust deklaráljuk.

Ha a formális paraméterlistában array of elemtípus típusú paramétert helyezünk el, "nyitott tömb paramétert" kapunk. A programraktárban az egyszerűség érdekében nem használunk nyitott tömb paramétereket.

Dinamikus tömbök átadása paraméterként

Mind a mutatókkal létrehozott, mind a Free Pascal beépített dinamikus tömb típusával deklarált dinamikus tömb változókban nem maga a tömb, hanem csak az első elem memóriacíme tárolódik. Ha ezt átadjuk egy szubrutinnak érték szerinti paraméterként, akkor a tömb nem kerül lemásolásra, tehát a hívó proigramban és a szubrutinban használt mutató ugyanarra a címre mutat. Így, bár a szubrutin a hívó programban érvényes változót nem változtathatja meg, az általa mutatott memóriaterületen lévő adatokat igen, tehát ha a szubrutinban a paraméterként átadott dinamikus tömbnek megváltoztatja egy elemét, az a hívó programban is megváltozik. Így visszaadhatunk adatokat a függvényből: pl. egy tömbsorbarendező eljárást megírhatunk úgy, hogy paramétere egy dinamukus tömb, és magában a tömbben dolgozik. Ha ezt nem akarjuk, a tömböt elemenként le kell másolni. Ha viszont egy Free Pascal dinamikus tömbnek megváltoztatjuk a méretét, új memóriacíme lesz, tehát ha egy értékparaméterként átadott dinamikus tömb méretét megváltoztatjuk a szubrutinon belül, akkor, mivel a hívó környezetben lévő változóban nem változik meg a cím, a hívó környezetben a tömb elemeinek későbbi elérése hibához vezet. Ha a tömb méretét is meg kell változtatni a szubrutinon belül, cím szerinti paraméterként adjuk át.