Programozás | Pascal » Vinnai Zoltán - Programozás-elmélet és Pascal

Adatlap

Év, oldalszám:2001, 34 oldal
Nyelv:magyar
Letöltések száma:1530
Feltöltve:2005. szeptember 18
Méret:371 KB
Intézmény:-

Csatolmány:-

Letöltés PDF-ben:Kérlek jelentkezz be!


Értékelések

Ezt a doksit egyelőre még senki sem értékelte. Legyél Te az első!


Új értékelés

Tartalmi kivonat

Programozás Kiegészítő jegyzet 2001 Készítette: Vinnai Zoltán Programozás Tartalomjegyzék Programozás elmélet . 4 1. A programkészítés lépései 4 1.1 A feladat megfogalmazása 4 1.2 A feladat modellezése 4 1.3 Az algoritmus meghatározása 5 1.4 A szükséges hardver és szoftver környezet megállapítása 5 1.5 Az algoritmus kódolása 5 1.6 A program tesztelése, hibakeresése, javítása 5 1.7 A hatékonyság növelése, optimalizálás 6 1.8 A dokumentációk elkészítése 6 1.81 Felhasználói dokumentáció 6 1.82 Fejlesztői dokumentáció 6 1.9 A működő program karbantartása, felügyelete 6 2. Az adatszerkezetek 6 2.1 Elemi adattípusok 6 2.2 Összetett adattípusok 7 3. Műveletek a számítógépen (programozási eszközök) 8 3.1 Értékadás 8 3.2 Adatbevitel és adatkiírás 8 3.3 Elágazások, feltételes programvégrehajtás 8 3.4 Ciklusszervezés 8 3.5 Függvények 9 3.6 Eljárások 9 4. Algoritmus leíró eszközök 9

4.1 Folyamatábra 9 4.2 Mondatszerű leírás 10 4.3 Struktrogram 11 5. Alapvető algoritmus típusok (programozási tételek) 11 5.1 Összegzés 11 5.2 Eldöntés 11 5.3 Kiválasztás 12 5.4 Keresés 12 5.5 Megszámlálás 12 5.6 Maximum- ill minimum kiválasztás 13 5.7 Kiválogatás 13 5.8 Rendezés 13 5.9 Szétválogatás 14 5.10 Metszetképzés 14 5.11 Egyesítés 15 5.12 Összefuttatás 15 6. Programozási módszerek 16 6.1 A "majd lesz valahogy" elv 16 6.2 Moduláris programozás 16 6.3 Struktúrált programozás 16 6.4 Objektum - Orientált Programozás -> OOP 16 6.5 Eseményvezérelt programozás 16 6.6 Vizuális programozás 17 Programozás Pascal nyelven . 17 1. Kialakulása 17 2. Pascal implementációk 17 3. Programkészítés TP60 segítségével 17 3.1 Parancssoros fordítóval – TPCEXE 17 3.2 A TP6 saját fejlesztői környezetét használva (IDE) 17 4. A Pascal forrás program felépítése (szintaktikája) 19 5. Unitok és

használatuk 21 Phare kísérleti program 2 Programozás 6. Változók és használatuk 21 7. A Pascal nyelvben használható változók típusai 21 7.1 Elemi adattípusok 21 7.2 Összetett adattípusok 22 7.21 Szöveg típus 22 7.22 Tömb típus 22 7.23 Felsorolt típusok 23 7.24 Résztartomány típus 23 7.25 Halmaz típus 23 7.26 Rekord típus 23 7.27 File típus 24 7.28 Egyéb összetett adattípusok 24 8. Konstansok és használatuk 24 9. Új típusok definiálása és használatuk 25 10. Műveletek, kifejezések, relációk 25 10.1 Számokon végezhető műveletek 25 10.2 Logikai műveletek 26 10.3 String műveletek 26 10.4 Halmaz műveletek 26 10.4 Összehasonlító műveletek 26 11. Programozási eszközök, vezérlési szerkezetek 26 11.1 Értékadás 26 11.2 Adatbevitel és adatkiírás 27 Kiírás . 27 Beolvasás. 27 11.3 Feltételes programvégrehajtás 27 11.4 Esetszétválasztás 28 11.5 Ciklusszervezés 28 Adott számú ismétlés: . 28

Elöltesztelő ciklus: . 28 Hátultesztelő ciklus:. 29 11.6 Eljárások 29 11.61 Globális és lokális változók 29 11.62 Paraméterek és kezelésük, cím szerinti és érték szerinti paraméter átadás 29 11.7 Függvények 30 12. Állománykezelés 31 12.1 Szöveges állománykezelés 31 12.2 Tipizált állománykezelés 32 12.3 Nem tipizált állománykezelés 32 13. Dinamikus memóriakezelés, mutatók és használatuk 32 13.1 Tipizált mutatók 33 13.2 Típus nélküli mutatók 34 Phare kísérleti program 3 Programozás Programozás elmélet 1. A programkészítés lépései Egyszerű esetben lehet úgy is programot írni, hogy egy-két mondatos feladat megfogalmazás után azonnal a számítógép elé ülünk, majd a feladatnak megfelelően begépeljük a szükséges utasításokat. Jobb esetben elindítjuk a programot, és ha hibát találunk, javítunk, majd valamilyen formában tároljuk. Ez mindaddig megy is, amíg egyszerűbb feladatról van szó, és

csak saját magunknak dolgozunk, de ha bonyolult, összetett feladatról van szó, akkor egy idő után megakadunk. Ha a program végre futni is fog és abban esetleg valamilyen változtatásra van szükség, akkor viszont vége, nincs tovább, újra kell írni. Ebben a részben olyan ismereteket fogunk tanulni, amelyek segítenek az ilyen buktatók kikerülésén és hatékonyan segítik a számítógépes munkánkat. A helyes programkészítés lépései: − a feladat megfogalmazása − a feladat modellezése − az algoritmus meghatározása − a szükséges hardver és szoftver környezet megállapítása − az algoritmus kódolása − a program tesztelése, hibakeresése, javítása − a hatékonyság növelése, optimalizálás − a dokumentációk elkészítése − a működő program karbantartása, felügyelete 1.1 A feladat megfogalmazása A feladat megfogalmazása a megoldás első lépése, amelynek során egyértelműen rögzíteni kell (lehetőleg írásban) az

elérendő célt a lehetséges pontossággal, a figyelembe vehető feltételekkel, különböző korlátok megadásával. Itt lehet elkövetni az első hibákat. Ha ugyanis a megfogalmazás nem világos, nem egyértelmű, akkor lehet, hogy a kész program nem egészen úgy és azt tudja, amit a feladat kitűzője gondolt. Feladat: Írassuk ki azon tanulók nevét, akik 4-esnél jobb tanulmányi eredményt értek el! Felmerülő kérdések: − Hol tároljuk a neveket és a tanulmányi eredményeket, a program elején kell beolvasni, vagy esetleg állományban, vagy valahol máshol tároljuk? − Maximum hány tanuló lehet? − Hova kell kiírni (képernyő, nyomtató) és hogyan írjuk ki, egymás mellé, egymás alá, egy oldalra egyet, vagy többet? − Rendezett-e a névsor a tanulmányi eredmény szerint, vagy sem? Ezeket a kérdéseket mindenképpen tisztázni kell, hogy a programot el tudjuk készíteni. 1.2 A feladat modellezése Annak ellenére, hogy a számítógép

felhasználásával megoldott feladatok nagy része nem matematikai problémaként fogalmazódik meg, az eredmény előállításához legtöbbször matematikai és logikai eljárások sorozatos alkalmazására van szükség. A megfogalmazott feladatokhoz ezért általában matematikai modellt kell keresni Ezek a modellek - mint az egyéb modellek - a valóság többé-kevésbé hű másai, esetünkben matematikai eszközökkel megvalósított másolatok. Pl. a feladat: egy adott osztály tanulmányi eredményének meghatározása egy adott tantárgyból A tanár így látja a megoldást: − vesszük az első tanuló eredményét majd hozzáadjuk a 2. tanulóét majd így tovább az utolsó tanulóig − majd ezt az összeget osztjuk az osztály létszámával. A matematikus: − tekintsük az eredményeket egy N-elemű számsorozatnak ekkor a tanulmányi eredmény: Phare kísérleti program 4 Programozás N TE = ∑ ai i =1 N Tehát a megoldás matematikai megfogalmazása,

modellje egyetlen rövid képletbe sűríthető. A modell alkotásának van egy olyan előnye is, hogy a különbözőnek látszó problémák ugyanazzal a módszerrel megoldhatók. Így előfordulhat, hogy már meglévő eljárásokat használhatunk fel, nem kell újra munkát befektetni 1.3 Az algoritmus meghatározása Az algoritmus meghatározása, a megoldási folyamatnak az eredmény előállításáig vezető logikai felépítése igen fontos lépése a problémamegoldásnak. Az algoritmusoknak feltétlenül rendelkezniük kell néhány alapvető tulajdonsággal. Ezek: Általánosság A megadott algoritmus nem csak a szóban forgó speciális feladat esetén vezessen a probléma megoldására, hanem a hasonló jellegű feladatok széles körére szolgáltasson helyes eredményt. Teljesség A választott algoritmus a feladatkör minden lehetséges megoldását szolgáltassa. Ehhez az szükséges, hogy a bemenő adatok minden szóba jöhető értékére (értelmezési tartomány)

felkészült legyen az algoritmus. A teljesség és az általánosság követelménye egymásnak ellentmondó ezért célszerű a két tulajdonságnak a megoldás szempontjából optimális kielégítését kitűzni. Végesség Az eredmény véges számú lépésben elérhető legyen. Egyértelműség Azonos körülmények között (ugyanolyan bemenő adatokkal) az eljárást megismételve azonos eredményeket kapjunk. Értelmezettség Legyen pontosan körülhatárolt az a bemenő adathalmaz, amelyre az algoritmus megoldást szolgáltat. 1.4 A szükséges hardver és szoftver környezet megállapítása Hardver környezet: meghatározza, hogy milyen típusú számítógép, minimálisan milyen részegységekből (pl. memória, háttértár kapacitás) épüljön fel, esetleg milyen speciális kiegészítőkre van szükség a program futtatásához. Szoftver környezet: az adott hardveren milyen egyéb programok futtatását igényli. A legfontosabb, hogy milyen operációs rendszer

(és milyen verziójú) szükséges a futtatáshoz. 1.5 Az algoritmus kódolása Kódolás: az algoritmus alapján a kiválasztott programozási nyelv szimbólumainak felhasználásával a program elkészítése. A programozási nyelvet célszerűen az adott feladathoz illeszkedően ´illik´ kiválasztani Ma már az a gyakoribb, hogy olyan programnyelven készül el a program, amelyet ismer a fejlesztő. Ez nem mindig a legoptimálisabb megoldáshoz vezet. Minden programozási nyelvnek megvannak a sajátosságai, amelyek bizonyos mértékig behatárolják, hogy hol és milyen feladatokat célszerű az adott nyelven megvalósítani. 1.6 A program tesztelése, hibakeresése, javítása Ez a fázis a programtermék elkészítése során talán a legtöbb figyelmet igényli. Ugyanis ha a programozó nem járja végig az összes lehetséges végrehajtási utat, amit a programfutás során el lehet képzelni, akkor az esetleges hiba csak a program használata során derül ki. Ez viszont

adatvesztéshez, akár anyagi kárhoz is vezethet Először meg kell vizsgálni, hogy a program az elvárt funkcióknak eleget tesz-e. Ez a tesztelés folyamata Ha ennek során hibajelzést kapunk, akkor azt meg kell keresnünk. Ez a hibakeresés Ha megtaláltuk a hibát, akkor azt javítanunk kell, ez a hibajavítás. Ezután ismételten meg kell győződnünk a program működésének helyességéről, s mindaddig folytatni az előbbiekben Phare kísérleti program 5 Programozás leírtakat, míg tökéletesen nem fut a programunk. 1.7 A hatékonyság növelése, optimalizálás A programozási tételek, algoritmusok csupán a program előkészítésének lehetőségét biztosítják, a program eredményessége mindig a programozótól függ. A hatékonyságot befolyásolja a végrehajtási idő, a program és adatainak helyfoglalása, valamint a bonyolultsága. 1.8 A dokumentációk elkészítése Kétféle dokumentáció létezik, egyik a felhasználó számára készül, míg

a másik a programozónak. 1.81 Felhasználói dokumentáció Ez a felhasználó számára készül. Önálló, a kész programmal együtt átadandó szöveg, mely megad minden a program használatához szükséges információt. Tartalmazza: − a feladat megfogalmazását − a programnyelv meghatározását − a futtatáshoz szükséges géptípust, konfigurációt - hardver feltételek − a program installálását, betöltését, indítását − a program használatát, kezelését − az esetleges hibajelzéseket és annak javítási lehetőségeit − egy tipikus futtatás teljes leírását − a program fejlesztési lehetőségét, annak feltételeit 1.82 Fejlesztői dokumentáció A programozóknak szól és a program fejlesztésével párhuzamosan készül. Részei: − a feladat megfogalmazása, pontosítása, általánosítása − az algoritmus részletes leírása − hardver és szoftver feltételek − változók meghatározása − az eljárások hierarchiáját

(szerkezetét) megadó táblázat − az eljárások nevei és feladatai − a program fejlesztési lehetőségei, feltételei − a program teljes listája, valamint egy háttértáron őrzött példánya 1.9 A működő program karbantartása, felügyelete A felhasználónak éreznie kell, hogy nem hagyták magára a mély vízben az új programmal az első számítógépén. Tudnia kell, hogy ha gondja, problémája van, mindig van valaki, aki segít. Ezt túlzásba sem szabad vinni, mindig az igényekhez kell alkalmazkodni. 2. Az adatszerkezetek Az adattípus megadása a típus értékkészletének, a rajta végzett műveleteknek, az értékek jelölésének és a tárban való ábrázolásának a rögzítését jelenti. Az adattípusok kétfélek lehetnek: elemiek amelyeknek felhasználói szempontból nincs belső szerkezetük, valamint összetettek, amelyek elemiekből épülnek fel, ezek az adatszerkezetek. 2.1 Elemi adattípusok Egész számok: Legtöbbször két byte-on

ábrázolják, kettes komplenens kódban. Így az értékkészlet a -32768 és 32767 közötti számok halmaza. Valós számok: A számítógépben kettes vagy tízes számrendszerben is ábrázolhatók a racionális számok. Megadásuk egy 0 és 1 közötti számmal és hatványkitevővel történik (számok normál alakja). Phare kísérleti program 6 Programozás Logikai érték: Igaz és hamis vagy TRUE és FALSE illetve 1 és 0. Karakter: Egy változóban tetszőleges karaktert tárolhatunk az ASCII kódtábla szerint. 2.2 Összetett adattípusok Az összetett adattípusokban az egyes adatelemek valamilyen sorrendi, szerkezeti összefüggésben állnak egymással. Tömb A tömb egy olyan sorozat, amelynek elemszáma rögzített és bármely elemére egy indexszel (sorszámmal) hivatkozhatunk. Általában a tömb elemei azonos típusúak Szöveg A szövegtípus hasonlít a tömbhöz. Elemei csak karakterek lehetnek, viszont az elemek száma (a szöveg hossza) változhat. A

szövegekkel műveleteket is lehet végezni (pl hozzáfűzés, részképzés) A verem Gyakran használt adatszerkezet, amelyet általában nekünk kell megvalósítani, ha szükségünk van rá. A verem adatok sorozatát tartalmazza, de csak speciális műveleteket engedünk meg vele kapcsolatban: − PUSH(x) - egy x értéket a verem tetejére (a sorozat végére) helyez. − POP(x) - a verem tetején (a sorozat végén) lévő értéket az x változóba teszi, majd a veremből eltávolítja A verem szerkezete LIFO (Last In First Out) típusú, ami azt jelenti, hogy az elsőnek betett elemet dolgozhatjuk fel először. A sor A sor olyan sorozat, amelynek az egyik végére lehet tenni az új elemeket, a másik végéről pedig el lehet venni őket. Ez a FIFO (First In First Out) típusú szerkezet, mely azt jelenti, hogy az elsőnek betett elemet dolgozhatjuk fel először. A lista A lista olyan szerkezet, mely megmondja, hogy egy adott elemet logikailag melyik követ. Egy adat mellé

egy vagy több mutatóértéket helyezhetünk el, amely mutatók a logikailag következő vagy előző elemet határozzák meg. Mindig van egy első elem ez a listafej és egy utolsó 1. Elem 2. Elem 3. Elem 4. Elem 0 elem, amelyet valamilyen formában megkülönböztetünk a listában előforduló elemektől. Ez lehet a 0 vagy a NIL illetve a NULL is. 1. Elem 2. Elem 0 3. Elem 4. Elem Ezen a példán jól látszik a lista előnye. A sorrend megváltoztatásához az elemeket nem kell mozgatni, csak a mutatókat kell átírni. A halmaz A halmaz olyan sorozat, ahol az elemeknek nincs definiálva a sorrendje, nincs értelme a következő elemet kérni. Használhatjuk viszont a halmazműveleteket: egyesítés, metszet, halmazkülönbség. A gráf A gráf olyan adatszerkezet, amely csúcsokból (adatelemek), valamint azokat összekötő élekből (kapcsolatok) áll. 67km Budapest Hatvan 84km 52km Újszász 73km 27km Szolnok Cegléd 23km Kecskemét 17km Az ilyen típusú szerkezetek

megvalósításához szintén a mutatókat használhatjuk. Bináris fa Egy speciális gráf, amelynél minden csúcs két éllel rendelkezik és van egy kitüntetett csúcsa a gyökér. Ezt a szerkezetet faszerkezetnek is nevezik Phare kísérleti program 7 Programozás A rekord Lényege, hogy az összetett változónak (rekord) adunk egy közös nevet, s az egyes, rendszerint különböző típusú mezőinek szintén. Így lehetővé válik a rekord elemeinek önálló, külön kezelése és a részek együttes feldolgozása is pl. személynyilvántartás − teljes személy: adat − neve: adat.név − születési éve: adat.születésidőév Alternatív szerkezet (változó szerkezet) Az alternatív szerkezet abban különbözik a rekordtól, hogy az egyes részek összetétele függ a tartalomtól, vagyis a rekord felépítése a mezők tartalmától függ. Adatállományok Ezek az adatszerkezetek a háttértárakhoz kapcsolódnak, olyan rekordsorozatok, amelyek

különbözőképpen szervezettek. Szekvenciális (sorrendi) állomány: A tárolt adatok csak a rögzítés sorrendjében nyerhetők vissza. Vagy csak olvasni, vagy csak írni lehet bele, illetve a végére új rekordot írni. Direkt állomány: Bármelyik rekordja bármikor elérhető, módosítható. Az egyes rekordokat általában sorszámmal tudjuk azonosítani Az ilyen állományba írhatunk, olvashatunk, illetve az állomány végére új rekordokat vehetünk fel. Indirekt állomány: Az indirekt állományok azt a lehetőséget biztosítják, hogy a rekordokat nem sorszámmal, hanem jellemző adatukkal azonosíthatjuk, pontosabban a rekordokat valamelyik mezője (kulcsmező) alapján rendezetten kezelhetjük. Ekkor az állományhoz tartozik egy táblázat, az indextábla, amely a kívánt adatot, valamint egy rekordra mutató értéket (rekordszám) tartalmaz. 3. Műveletek a számítógépen (programozási eszközök) 3.1 Értékadás A változóknak adhatunk új értéket. A

változók olyan tároló elemek, amelyeket névvel azonosíthatunk és a típusoktól függően különböző értékeket tárolhatnak. A programvégrehajtás során a változók értékei változhatnak pl.: A VÁLTOZÓ:=1 => A VÁLTOZÓ legyen egyenlő 1-el. 3.2 Adatbevitel és adatkiírás Ezeknek az utasításoknak a segítségével a program és a külvilág közötti adatcserére nyílik lehetőségünk. A bevitel általában a billentyűzetről vagy háttértárolóról történik. A kivitel általában a monitor, a nyomtató vagy a háttértároló segítségével valósul meg. 3.3 Elágazások, feltételes programvégrehajtás Az egyes programrészek végrehajtása egy logikai feltételtől függ. Ha a logikai feltétel igaz, akkor az egyik utasítás vagy utasítássorozat kerül végrehajtásra, ha nem, akkor a másik utasítás vagy utasítássorozatok hajtódnak végre. pl.: Ha feltétel akkor utasítások1 különben utasítások2 Elágazás vége 3.4 Ciklusszervezés

Akkor alkalmazzuk, ha egyes utasításokat többször egymás után végre szeretnénk hajtatni. Több lehetőség is van: Phare kísérleti program 8 Programozás Adott számú ismétlés A ciklusmag utasításai a ciklusváltozó kezdő és végértékének, valamint a lépésköznek megfelelő számszor kerülnek végrehajtásra. Pl: Ciklus ciklusváltozó = kezdőérték-től végérték-ig lépésköz-ösével : : Ciklusmag : Ciklus vége Elöltesztelő ciklus (mert a feltételvizsgálat a ciklus elején történik) A ciklusmag utasításait addig kell végrehajtani, amig a feltétel igaz. Pl: Ciklus amíg feltétel : : Ciklusmag : Ciklus vége Hátultesztelő ciklus (mert a feltételvizsgálat a ciklus végén történik) Az előzőhöz hasonló, azzal a különbséggel, hogy a ciklusmag utasításait egyszer mindenképpen végre kell hajtani. Pl: Ciklus : : Ciklusmag Amíg feltétel Ciklus vége 3.5 Függvények A függvények fő sajátossága, hogy nevük egy értéket

képvisel. Típusuk pontosan meghatározott A függvényekre nevük és paramétereik leírásával hivatkozhatunk. Pl: SIN(x) függvény az x szám szinuszát jelenti. 3.6 Eljárások Az eljárások annyiban különböznek a függvényektől, hogy nem értéket, hanem valamilyen tevékenységet képviselnek. Ezekre is nevükkel és paramétereikkel hivatkozhatunk. 4. Algoritmus leíró eszközök Célja: a megoldás menetének géptől független, szemléletes, a logikai gondolatmenetet, a szerkezeti egységeket világosan tükröző leírása. 4.1 Folyamatábra A folyamatábra a feladat megoldási lépéseinek sorrendjét utasítástípusonként különböző geometriai alakzatok felhasználásával szemléltető ábra. Szimbólumok és jelentéseik: Phare kísérleti program 9 Programozás - határszimbólumok, a program elejét és végét jelzik Stop Start Be - beolvasó és kiíró utasítások vagy Ki - értékadó utasítás, művelet végrehajtás, aritmetikai

kifejezés kiértékelése n - elágazás, a feladat végrehajtás a rombuszba írt feltétel alapján egyik vagy másik irányban folytatódik, a kér kimenet: Igaz (i), vagy Nem (n) i pl: Ciklusszervezés Start A folyamatábrákban nyilakkal jelöljük a haladás irányát. Folyamatábra készítése, csak egyszerűbb algoritmusok esetén javasolt, mivel egy bonyolultabb szerkezeten nehéz követnünk a lépéseket. I:=1 Ki: I I:=I+1 I=10? i Stop n 4.2 Mondatszerű leírás Az algoritmus egymást követő lépéseit mondatokkal vagy mondatszerű szerkezetek egymásutánjával próbáljuk leírni. Két fajtája van. Mondatok Egyszerűbb esetben a mondatok sorozata írja le a feladatok megoldását. Ezeket sorszámmal látjuk el, hogy később hivatkozni tudjunk rajuk. Pl: Feladat: olvassunk be N db természetes számot, és határozzuk meg ezek összegét. Algoritmus: 1. N beolvasása 2. Ha N<=0 vagy N nem egész szám, akkor 1 3. S:=0 4. Ciklus I=1-töl N-ig : A

beolvasása : S:=S+A : Ciklus vége 5. S kiírása Mondatszerű szerkezetek Szemléletesebb az, amikor mondatok helyett csak ún. mondatszerű szerkezetek egymásutánjával írjuk le a feladat megoldását. Ha ezeket a mondatszerű szerkezeteket definiáljuk, rögzítjük, akkor tulajdonképpen egy algoritmus leíró nyelvet hozunk létre. Egy példa algoritmus leíró nyelvre: Értékadás: változó := kifejezés Beolvasás: Be: változók felsorolása {az adatokkal szemben támasztott követelmények} Kiírás: Ki: kifejezések felsorolása {a kiírás formájára vonatkozó követelmények} Elágazások: Lásd Műveletek számítógépen Ciklusszervezés: Lásd Műveletek számítógépen Eljárások: eljárásnév (paraméterek) : : az eljárás utasításai : Eljárás vége Egyéb jelölések: Phare kísérleti program 10 Programozás − Egy sorba több utasítást is írhatunk, de közéjük ";"-t vagy ":"-t kell tenni. − Megjegyzések { } között.

− Alkalmazzunk bekezdéseket az egyes szerkezetek megkülönböztetésére. Pl.: Az előző feladat algoritmusa: Program Be: N { N>0, egészek } S:=0 {Az elemek összegét tárolja} Ciklus I=1-től N-ig Be: A S:= S+A Ciklus vége Ki: S Program vége. 4.3 Struktrogram A struktogram elkészítése során az algoritmust egy téglalapba készítjük el, mely tartalmazza az utasítások szövegét. Majd ehhez továbbiak illeszthetők. A téglalapokba az egymás utáni utasítások kerülnek bele. 1. utasítás 2. utasítás Elágazás esetén a téglalapot három részre osztjuk. A felső részbe a feltétel kerül. A végrehajtás azon az oldalon folytatódik, amelyik állítás teljesül Feltétel Hamis Igaz Következő utasítás Következő utasítás Ciklus esetén két téglalapot egymásba ágyazunk. Feltétel Ciklusmag 5. Alapvető algoritmus típusok (programozási tételek) 5.1 Összegzés Általános feladat: Adott egy N elemű számsorozat. Számoljuk ki az elemek

összegét! A sorozatot egy N elemű A(N) tömbben tároljuk Algoritmus Eljárás S:=0 {Az elemek összegét tárolja} Ciklus I=1-től N-ig S:=S+A(I) Ciklus vége Eljárás vége. Konkrét feladat az alkalmazásra. Átlagszámítás 5.2 Eldöntés Általános feladat Adott egy N elemű sorozat és egy, a sorozat elemein értelmezett T tulajdonság. Feladat annak eldöntése, hogy van-e a sorozatban legalább egy T tulajdonsággal rendelkező elem. Phare kísérleti program 11 Programozás Algoritmus Eljárás i:=1 ciklus amíg i<=N és A( i ) nem T tulajdonságú i:=i+1 Ciklus vége. VAN := i<=N {VAN egy logikai változó, igaz értéke jelzi, hogy nem T tulajdonságú elem} Eljárás vége. Alkalmazás Volt-e egy adott tantárgyból bukás egy adott osztályban? Számsorozat: jegyek; T tul.: 1-es jegy 5.3 Kiválasztás Általános feladat Adott egy N elemű sorozat, egy, a sorozat elemein értelmezett T tulajdonság, valamint tudjuk, hogy a sorozatban van legalább egy T

tulajdonságú elem. A feladat ezen elem sorszámának meghatározása Algoritmus Eljárás I:=1 Ciklus amíg A(I) nem T tulajdonságú I:=I+1 Ciklus vége SORSZ:=I Eljárás vége Alkalmazás Keressük meg, hogy NAGY PISTI hányadik a névsorban. { A( ) } 5.4 Keresés Általános feladat Adott egy N elemű sorozat és egy, a sorozatban értelmezett T tulajdonság. Feladat: eldönteni, hogy van-e T tulajdonságú elem a sorozatban, és ha van, akkor adjuk meg a sorszámát is. Algoritmus A keresési feladatokra több algoritmus is ismert lineáris, logaritmikus. Mi most csak a legegyszerűbbet ismerjük meg a lineárist. Eljárás I:=1 Ciklus amíg I< =N és A(I) nem T tulajdonságú I := I+1 Ciklus vége VAN := I< =N Ha VAN, akkor SORSZ := I Eljárás vége Alkalmazás Ismert egy osztály névsora { A( ) }. Adjunk meg egy NAGY vezetéknevűt! 5.5 Megszámlálás Általános feladat Adott egy N elemű sorozat és egy T tulajdonság. Számoljuk meg, hogy hány ilyen T

tulajdonságú elem van a sorozatban! Phare kísérleti program 12 Programozás Algoritmus Eljárás S := 0 Ciklus I=1-től N-ig Ha A(I) T tulajdonságú, akkor S := S+1 Ciklus vége Eljárás vége Alkalmazás Osztály névsora ismert. Adjuk meg a Nagy vezetéknevűek számát! 5.6 Maximum- ill minimum kiválasztás Általános feladat Egy sorozat legnagyobb, ill. legkisebb elemének sorszámát kell megtalálni Algoritmus Max. elem INDEX := 1 Ciklus I=2-től N-ig Ha A( INDEX)< A(I) akkor INDEX := I Ciklus vége MAX INDEX := INDEX Eljárás vége Alkalmazás Ismert egy osztályban {N} a 60m-es futás időeredménye { A( ) }. Adjuk meg a leggyorsabb tanuló nevét { B( ) }! 5.7 Kiválogatás Általános feladat Egy N elemű sorozat összes T tulajdonsággal rendelkező elemét kell meghatározni. A kiválogatott elemeket gyűjtsük a B( ) tömbbe! Algoritmus Eljárás J := 0 Ciklus I=1-től N-ig Ha A(I) T tulajdonságú, akkor J := J+1; B(J) := I Ciklus vége Eljárás vége

Alkalmazás Ismert egy osztályban {N} a 60n-es futás időeredményei { A( ) }. Adjuk meg azon tanulók nevét, akik egy X időnél jobb időt futottak { B( ) }! 5.8 Rendezés Általános feladat Adott egy rendezetlen sorozat. Feladat a sorozat adott tulajdonsága szerint növekvő vagy csökkenő sorrendben rendezett sorozat előállítása. Algoritmus Igen sokféle rendezési algoritmus van. Az, hogy melyiket választjuk, függ a módszer tárigényétől, a végrehajtási időtől, az eljárás során végrehajtott összehasonlítások, ill. mozgatások, cserék számától A legegyszerűbb a közvetlen kiválasztásos rendezés. Eljárás Ciklus I=1-től N-ig Ciklus J=1-től N-ig Phare kísérleti program 13 Programozás Ha A(J)< A(I) akkor A := A(J); A(J) := A(I); A(I) := A Ciklus vége Ciklus vége Eljárás vége Alkalmazás Egy osztály tanulóinak névsorba rendezése. 5.9 Szétválogatás Általános feladat Adott egy sorozat, valamint egy kijelölt elem (pl. X=A(1)

Cseréljük fel úgy a sorozat elemeit, hogy az X-nél kisebbek X előtt legyenek, a nála nagyobbak pedig utána. Algoritmus Eljárás X := A(1) E := 1 U := N ciklus amíg E<U ciklus amíg E<U és A(U)>=X U := U-1 ciklus vége Ha E<U akkor A(E) := A(U) E := E+1 ciklus amíg E<U és A(E)<=X E:=E+1 Ciklus vége Ha E<U akkor A(U) := A(E) U := U-1 Elágazás vége Elágazás vége Ciklus vége A(E):=X Eljárás vége Alkalmazás Egy osztály tanulóiról tudjuk, hogy ki fiú és ki lány. Feladat olyan sorrend előállítása, ahol a lányok vannak elől, a fiúk pedig a végén. 5.10 Metszetképzés Általános feladat Adott egy N és egy M elemű halmaz az A( ) és a B( ) tömbökben. Készítsük el a két halmaz metszetét a C( ) tömbbe Két halmaz metszetébe azok az elemek tartoznak, amelyek mindkettőben szerepelnek. Algoritmus Eljárás CN:=D ciklus I=1-től N-ig J:=1 ciklus amíg J<=M és A(I)< >B(J) J:=J+1 ciklus vége Ha J<=M akkor CN := CN+1

C(CN):=A(I) Phare kísérleti program 14 Programozás Elágazás vége ciklus vége Eljárás vége Alkalmazás Adott egy osztály névsora és adott azoknak a tanulóknak a névsora, akik az iskolában vannak gyakorlati oktatáson. Feladat az adott osztályból azon tanulók nevének kiíratása, akik az iskolában vannak gyakorlaton. 5.11 Egyesítés Általános feladat Adott egy N és egy M halmaz az A( ) és a B( ) tömbben. Készítsük el a két halmaz egyesítését (unióját) a C( ) tömbben! Az unióba azok az elemek tartoznak, amelyek legalább az egyikben szerepelnek! Algoritmus Eljárás ciklus I=1-től N-ig C(I):=A(I) Ciklus vége CN:=N ciklus J:=1-től M-ig I:=1 ciklus amíg I<=N és A(I)< >B(J) I:=I+1 ciklus vége Ha I>N akkor CN:=CN+1 C(CN):=B(J) Elágazás vége ciklus vége Eljárás vége Alkalmazás Adott két lista. Az egyikben szerepelnek azok a tanárok, akik az iskola dolgozói, vagyis innen kapják a fizetésüket A másik listában

szerepelnek a külső óraadók. Feladat mindazon tanárok nevének kilistázása, akik az iskolában bármit tanítanak. 5.12 Összefuttatás Általános feladat Adott két rendezett sorozat A(N) és B(M). Állítsunk elő belőlük egy sorozatot, hogy a rendezettség megmaradjon és az eredeti sorozatok minden eleme szerepeljen benne. (Az unio speciális esete) Algoritmus Eljárás I := 1 J := 1 K := 0 A( N+1 ) := +végtelen B( M+1) := +végtelen Ciklus amíg I<N+1 vagy J< M+1 K:=K+1 Ha A( I )<B(J) akkor C( k) := A(J) I := I+1 Elágazás vége Ha A(I) > B( J) akkor C(k) := B(J) J:=J+1 Phare kísérleti program 15 Programozás Elágazás vége Ha A(I)=B(J) akkor C(J) := A(J ) I := I+1 J := J+1 Elágazás vége Ciklus vége Eljárás vége Alkalmazás Az előző feladat névsorba rendezett listák esetén. 6. Programozási módszerek 6.1 A "majd lesz valahogy" elv A feladat ismertetése után, mindenféle előzetes gondolkodás nélkül leülünk a gép elé

és nyomkodjuk a billentyűt. Azután meg majd lesz valahogy. Általában mindenki így kezdi. Ez a próbálkozások, kísérletezések időszaka A lehetséges hibaüzenetek megismerésének időszaka. Egy összetettebb feladat esetén túlnőhet rajtunk, ismeretlenné válik a program Egy komolyabb javítás felér egy öngyilkossági kísérlettel. 6.2 Moduláris programozás Lényege, hogy az adott feladat felbontható olyan részfeladatokra, amelyeket egymástól függetlenül is el lehet készíteni és le lehet tesztelni. Ilyenkor csak arra kell figyelni, hogy az egyes rutinok milyen változókon, paramétereken keresztül vannak kapcsolatban. Ezeket a változókat, paramétereket azután a munka megkezdése előtt pontosan meg kell határozni, rögzíteni kell. Általában nagyobb méretű programok esetén alkalmazzák, így egyszerre több programozó tud dolgozni ugyanazon a programrendszeren. 6.3 Struktúrált programozás Lényege, hogy az adott feladatot először

globálisan, teljes körűen kell definiálni. Vagyis egy modellt kell készíteni, ami a legjobban lefedi a feladat összes jellemzőjét. Definiálni kell a bemeneti (input) és kimeneti (output) adatokat, és azokat a műveleteket, melyeket a programnak a bemeneti adatokkal el kell végezni, hogy a megfelelő kimeneti adatokat kapjuk meg. Ezek után a feladatokat lépésenként egyre jobban finomítani kell, míg el nem jutunk a program utasítások szintjére. Ez bonyolultabb feladat esetén soklépéses folyamat, de célszerű következetesen végigvinni (mivel így biztos, hogy nem fogunk összekeveredni a rutinok között). Jól definiált helyeken jól tesztelhető programhoz jutunk, és egyben a dokumentáció is majdnem készen van. 6.4 Objektum - Orientált Programozás -> OOP Az OOP az eddigi módszerekkel ellentétben a valóság hű megközelítésén alapszik. Az OOP-ben, úgy mint a valós világban is, a programozó tárgyakat (object - objektum) kezel. Minden

tárgyat nemcsak alakja, elhelyezkedése jellemez, hanem az is, hogyan viselkedik bizonyos körülmények között. Az OOP-ben ezt a két jellemzőt statikus és dinamikus tulajdonságoknak nevezik. Egy objektum deklarálásakor definiálni kell a szerkezetét és azokat a szubrutinokat is, melyek az objektum viselkedését írják le. Az OOP előnye, hogy ezeket a tulajdonságokat így együtt lehet kezelni valamint, hogy egy objektum örökölhet tulajdonságokat egy másik objektumtól. 6.5 Eseményvezérelt programozás Az eseményvezérelt programozás az egyik legújabb programozási technika. Filozófiája is teljesen eltér az eddigi programozási technikáktól. Az előző technikák esetében mindig a programozó döntötte el, hogy milyen sorrendben követik egymást az egyes feladatokhoz tartozó utasítások, eljárások. Az eseményvezérelt programozásnál a programozó sohasem tudja előre, hogy milyen feladatot kell elvégezni a következő pillanatban, csak azt

tudja, hogy milyen események (event) történhetnek, és ezekhez az eseményekhez milyen feladatok tartoznak. Egy esemény lehet például egy billentyű lenyomása vagy az egér elmozdítása is. Phare kísérleti program 16 Programozás 6.6 Vizuális programozás A programok futási képernyőjét tervezzük meg tulajdonképpen úgy, hogy az eredmény azonnal látszik is. Ezek a nyelvek felhasználják az OOP és az eseményvezérelt programozás adta lehetőségeket. Megszabadítanak minket sok programozói munkától, mivel a futási képernyő előállítása automatikus. Pontosabban kész elemekből felépítjük a képernyőt, és az a programfutás során ugyanúgy jelenik meg, ahogyan definiáltuk. Az egyes elemekhez itt is események vannak hozzárendelve. Nekünk csak kiegészíteni kell a programot, hasonlóan az eseményvezérelt programozáshoz Mivel ezek a programnyelvek tulajdonképpen programrészeket állítanak elő automatikusan, szokták ezeket 4GL

nyelveknek is nevezni. A 4GL a 4 generációs nyelv rövidítése Egyes rendszerek tényleg képesek arra, hogy automatikusan forrásprogramot is előállítsanak. A programozási módszerek közül a programozónak kell választania a követelményeknek és az esetleges fejlesztési igényeknek megfelelően. Mindig azt a módszert kell kiválasztani (esetleg többet is), amellyel a leghatékonyabban tudja elkészíteni az adott programot. Programozás Pascal nyelven 1. Kialakulása − 1968 Nicklaus Wirth kifejezetten oktatási célra fejlesztette ki − 1970 az első fordítóprogram − 1973 definiálták a szabványos (standard) Pascal nyelvet − az első változatok nagygépes rendszerekre készültek, de amikor megjelentek a személyi számítógépek, akkor kiderült, hogy ezekre is kiváló fordítóprogramokat lehet készíteni − nagyon sok implementációja (megvalósítása, verziója) létezik, melyek között lényeges eltérések is vannak, legelterjettebb a Turbo

Pascal (Borland) 2. Pascal implementációk Több cég készített és ma is készít pascal fordító programokat. A Pascal nyelvet elsősorban DOS-os programok készítésére tervezték, de már léteznek olyan megvalósítások is, amelyekkel Windows 3.x, Windows 9x operációs rendszerek alatt futó programokat is készíthetünk. PC-kre létező fordító programok: − Turbo Pascal és verziói (1.0, 20, , 55, 60, 70) − Turbo Pascal for Windows (kifejezetten Windows-os programok készítésére) − Borland Pascal (DOS és Windows programok készítésére) − Free Pascal (DOS és Windows programok készítésére) − Delphi (kifejezetten Windows-os programok készítésére vizuális környezetben) A továbbiakban a Turbo Pascal 6.0 verziója lesz a kiindulópontunk A Pascal nyelvvel kapcsolatban leírtak azonban nemcsak erre a verzióra igazak, hanem minden Pascal implementációra is. 3. Programkészítés TP60 segítségével A TP6.0 segítségével kétféleképpen

készíthetünk futtatható (EXE vagy COM) programot: 3.1 Parancssoros fordítóval – TPCEXE − először valamilyen szövegszerkesztővel elkészítjük a program forrását, ezt egy. PAS kiterjesztésű fájlba mentjük (pl.: ELSOPAS) − majd a TPC.EXE segítségével elkészítjük a futtatható programot (EXE-) TPC ELSO.PAS parancs hatására elkészül az ELSO.EXE futtatható program EDIT ELSO.PAS TPC ELSO.PAS ELSO.EXE 3.2 A TP6 saját fejlesztői környezetét használva (IDE) Phare kísérleti program 17 Programozás IDE – Integrated Development Environment (Integrált fejlesztői környezet Az IDE indítása a TURBO begépelésével történhet. Ekkor elindul az IDE, egy menüvezérelt alkalmazás, amelynek segítségével hatékonyabban készíthetők el programjaink. Az IDE előnyei: − menüvezérelt rendszer − szövegszerkesztőként is használható − egyszerre több forrást is szerkeszthetünk − azonnali futtatás lehetősége (nem kell kilépni az

IDE felületből) − azonnali fordítás lehetősége − lépésenkénti (soronkénti) programvégrehajtás lehetősége − a programban használt változók értékének folyamatos nyomkövetése a lépésenkénti végrehajtás során − beépített segítség (HELP) rendszer A menüvezérelt rendszer azt jelenti, hogy az egyes lehetőségek menü pontokból választható ki. Van egy főmenü, ami az elindítás után rögtön látható (File Edit Search, stb). A főmenü egyes elemeit kiválasztva újabb menüpontok jelennek meg, amelyekből akár megint újabb menüpontok jelenhetnek meg. A menü kezelése történhet billentyűzettel illetve az egér segítségével is. Billentyűzetről az <ALT> + valamelyik másik billentyű lenyomásával juthatunk a főmenübe Minden menüpont egyik betűje ki van emelve, a File menüpontnál az F. Ha az <ALT>+<F> kombinációt nyomjuk le, akkor a File menüt nyitottuk ki, ahogy a képen is látszik: A menüpontok

között pedig a kurzor (nyilas: ←, ↑, →, ↓) billentyűkkel navigálhatunk. A menüpont kiválasztása az <ENTER> billentyűvel történik. A beépített szövegszerkesztő a DOS EDIT programjához hasonló szolgáltatásokat nyújt, amelyeket csak akkor tudunk használni, ha megnyitottunk egy forrás fájlt (File / Open), vagy új forrást akarunk készíteni (File / New): − mozoghatunk a teljes szövegben (kurzor billentyűk) − sor elejére ugorhatunk (<HOME>) − sor végére ugorhatunk (<END>) − egy képernyőnyit ugorhatunk felfelé (<PAGEUP> / <PGUP>) − egy képernyőnyit ugorhatunk lefelé (<PAGEDOWN> / <PGDN>) − törölhetünk egy karaktert (<DEL> vagy <BackSpace> / <>) − törölhetünk egy teljes sort (<CTRL>+<Y>) − szerkesztési üzemmódot válthatunk , beszúró vagy felülíró mód (<INS>) − kijelölhetünk szövegrészeket, amelyekkel további műveletek végezhetők

(<SHIFT> nyomva tartása mellett kurzor billentyűk illetve a <PAGEUP>, <PAGEDOWN>) − kijelölt szövegterület törlése (<SHIFT>+<DEL>) − kijelölt szövegterület másolása egy átmeneti tárolóterületre, ahonnan visszamásolható (<CTRL>+<INS>) − a tároló helyen lévő szöveg másolása a kurzor pozíciójába (<SHIFT>+<INS>) − kijelölt szövegterület jobbra mozgatása (<CTRL>+<K> és <CTRL>+<I>) − kijelölt szövegterület balra mozgatása (<CTRL>+<K> és <CTRL>+<U>) A lehetőségek közül leginkább a segítség rendszert (HELP) emelném ki. Elindítása az F1 funkcióbillentyű lenyomásával történik. Itt információk találhatók az IDE kezelésével kapcsolatban, valamint a Pascal nyelv szintaktikájával és használatával kapcsolatban is. Ha valamilyen utasítás hirtelen nem jut eszünkbe, azt a Help-ben megtalálhatjuk teljes leírásával

egyetemben, valamint példaprogramokat is a használatához. Nagyon hasznos tud lenni Az eredeti HELP ugyan angol nyelvű, de elkészült a teljes magyarítása is. Phare kísérleti program 18 Programozás Akkor is segíthet, ha ismerem ugyan az utasítást, de nem tudom hogyan kell használni. Ekkor be kell írni az utasítást, majd a kurzorral a beírt utasításra állni és lenyomni a <CTRL>+<F1> billentyű kombinációt. Ekkor az adott utasításhoz tartozó segítség jelenik meg. Az elkészült program futtatása a <CTRL>+<F9> kombináció segítségével vagy menüből a Run / Run menüponttal történik. Kipróbálásához írjuk be első Pascal programunkat: Begin WriteLn(’Hello’); End. A program kiírja a képernyőre a Hello szöveget. Futtatás után nem láttunk semmi változást Ahhoz, hogy a program eredményét lássuk, le kell nyomni az <ALT>+<F5> kombinációt. Ekkor jelenik meg a futtatási képernyő Ha most még egy

billentyűt lenyomunk, visszatérünk az IDE felületbe. Ha .EXE állományt is szeretnénk látni a fordítás végén, akkor Compile menü Destination menüpontjában a Disk szöveget kell látnunk. Ez a menüpont érdekesen működik, ha kiválasztjuk, akkor mintegy kapcsolóként hol Memory lesz mellette, hol pedig Disk. Ha csak .EXE állományt akarunk készíteni, akkor az <F9> billentyűt kell lenyomni, vagy a Compile / Make menüpontot kiválasztani. Az IDE felületből kilépni az <ALT>+<X> billentyű kombinációval vagy a File / Exit menüponttal lehet. 4. A Pascal forrás program felépítése (szintaktikája) Ez egy általános felépítés, nem kell minden eleméhez ragaszkodni (ahogy az első programunknál is láttuk): Program program nev; {program fej, a program rövid nevét adhatjuk meg} Uses unitnev, unitnev; {a felhasználni kívánt unit-ok neveinek felsorolása} Const konstansnev = konstanertek; {konstansok deklarációja} konstansnev =

konstanertek; Type tipusnev = tipusdefinico; {típusok deklarációja} tipusnev = tipusdefinico; Var valtozonev, . valtozonev : típus; {globális változók deklarálása} valtozonev, . valtozonev : típus; Label labelnev, labelnev; {cimkék deklarációja} Procedure eljarasnev(parameterek); {eljárások deklarációja} Function funkcionev(parameterek); {funkciók deklarációja} Begin {főprogram kezdete} {főprogram utasításai} End. {főprogram vége, a . lényeges!} A programfej kötelezően a Program kulcsszóval kezdődik, amelyet a program neve (azonosítója) követ. Jó, ha programnévként olyan nevet adunk, ami utal a program feladatára, és célszerű a programot ezen a néven is menteni (hajlékony vagy merev-) lemezre. Mentéskor a program automatikusan PAS kiterjesztést kap, ezt külön nem is kell megadnunk. A fájlnév-adás kötöttségei egyébként ugyanazok, mint a DOS-ban (8 angol karakter stb) A programfejben kell megnevezni a uses kulcsszó után

azokat a rendszerhez tartozó egységeket (unit-okat), amit a programírás megkövetel. Az egységekről a későbbiekben még lesz szó, most csak annyit, hogy ezekben helyezkednek el - megfelelő csoportosításban - a Turbo Pascal parancsai, utasításai. Ilyen unit-okat természetesen a programozó is készíthet, de ez inkább csak a nagy méretű programok esetén indokolt. A deklarációs részben azt adjuk meg, hogy milyen típusú változókkal fogunk dolgozni (type), az adott típusú változóknak milyen nevet adunk (var), milyen állandókat (konstansokat) szerepeltetünk a programban (const), valamint itt kell megadni a programban alkalmazott címkéket is (label). Mindezek a jellemzők globális jellegűek, ami azt jelenti, hogy érvényességi tartományuk az egész program. Ebből az is következik, hogy ugyanezeknek megvannak a lokális Phare kísérleti program 19 Programozás megfelelőik is, amelyek a programnak csak egy meghatározott részére érvényesek.

Az eljárás- és függvényblokk azokat az eljárásokat és függvényeket tartalmazza, amelyeket a programtervezés során hoztunk létre. Az eljárásokban azokat a feladatrészeket helyezzük el, amelyek logikailag, funkcionálisan egy egységet képeznek (a feladat részekre bontásáról már volt szó korábban!). Egyszerű esetben például az egyik eljárásban az adatbevitelt szerepeltethetjük, egy másikban az adatokkal való manipulálást, egy harmadikban pedig az eredmények kiíratását. Az eljárás mindig a procedure kulcsszóval kezdődik, amit a neve követ, utána opcionálisan a paraméterek, a sort pedig pontosvesszővel zárjuk le. A végrehajtandó parancssorokat a begin (kezdés) után soroljuk fel, az eljárás végét pedig az end (vége) szóval jelöljük, utána pedig pontosvesszőt teszünk (a begin után soha nem teszünk pontosvesszőt!). Egyébként a parancssorokat is mindig a pontosvesszővel kell lezárni. Hiába írunk külön sorba valamit, ha

nem teszünk közéjük pontosvesszőt, a fordító egy sornak fogja tekinteni az egészet. A függvény felépítése nagyjából hasonló az eljáráshoz, csak function kulcsszóval kezdődik, és mindig van paramétere. A főprogram szintén a begin és az end kulcsszavak között helyezkedik el, de itt az end után pontot teszünk, ezzel jelezzük, hogy vége a programnak. A főprogram a programunk végrehajtó része Itt hivatkozunk azokra az eljárásokra és függvényekre, amelyek az eljárás- és függvényblokkban helyezkednek el. Például megnevezzük az adatbevitelért felelős eljárást, majd a feldolgozó eljárást, végül pedig a kiírató eljárást. A Pascal nyelvnek vannak bizonyos fenntartott szavai, amit a rendszer használ. A foglalt szavakat, vagy kulcsszavakat a programozónak nem szabad használni a programban változók, konstansok, eljárások, vagy bármi más elnevezésére. A foglalt szavakat foglalja össze a következő táblázat: and asm array

begin case const constructor destructor div do downto else end exports file for function goto if implementation in inherited inline interface label library mod nil not object of or packed procedure program record repeat set shl shr string then to type unit until uses var while with xor Az azonosítók a program bizonyos elemeinek elnevezésére szolgálnak. Azonosítókat maga a Pascal is tartalmaz, pl az Integer, a ReadLn, vagy a Write. Vannak azonban olyan elemek, amiket nekünk kell elnevezni, pl a programnak nevet kell adni, az egyes változókat, konstansokat, eljárásokat is el kell keresztelni. Az azonosító ASCII karakterekből állhat (kis- és nagybetűk, számjegyek). Vannak azonban bizonyos megszorítások: − kis- és nagybetűket (ékezet nélkül!) tetszés szerint használhatunk − számmal nem kezdődhet, de lehet benne − kötőjel nem, de aláhúzásjel ( ) lehet benne − szóköz, *, !, ? nem lehet − azonos változó- vagy konstansnév nem szerepelhet

kétszer (eltérő típus esetén sem) − fenntartott szó nem lehet − hossza nem meghatározott (de csak az első 63 karakter számít). Az elmondottak értelmében jó nevek lehetnek a következők: Hki, Hallgatok, Folyo Ev, Bbe1, Bbe2, ALMA Ezek azonban rosszak: 2Bbe, Hallgatók, Folyó Év, 222, Egy*Egy, Gyere! Ahhoz, hogy a fordító tudja, hogy pl. a Hallgatok egy változónk azonosítója, a deklarációs részben közölni kell vele Saját változóink nevét a típusmegadás és a változók felsorolása helyén adhatjuk meg (a type és a var kulcsszavak után). Az azonos típusú változókat vesszővel elválasztva lehet felsorolni. Fontos! A Pascal nyelv a kis- és nagybetűk között nem tesz különbséget. A Pascal program elválasztó szimbólumai a szóköz és a sorvég-jel. A szóköznek a programozás elemeinek felsorolásakor van jelentősége (a használatos szavak közé szóközt teszünk, ez természetes), a sorvég jel pedig általában pontosvessző (a

program végén lévő end után pont). Ha egy programsor után nem teszünk pontosvesszőt, akkor a fordító a következő sort is az előző folytatásának fogja tekinteni. A forrásnyelvi program sorokból áll. Minden sor maximálisan 126 karaktert tartalmazhat, de ezt nem célszerű Phare kísérleti program 20 Programozás kihasználni. A képernyőn egyébként is maximálisan csak 80 karakter fér el (sőt a szövegszerkesztő ablak kerete miatt még kevesebb). A program sorai pontosvesszővel vannak lezárva, de ez csak formai felépítés, az egyes sorok akár egymás mellett is lehetnek. Ez azt jelenti, hogy a pontosvessző csak az egyes utasítások szétválasztására szolgál, nem pedig a sorok lezárására. A program adott helyein megjegyzéseket helyezhetünk el, ha indokolt. A megjegyzéseket kapcsos zárójelek közé tesszük, de használhatjuk a (* és ) párokat is. Megjegyzés lehet például: {Az adatbeolvasas kezdete} , (* Az n szerinti ciklus vege ) .

5. Unitok és használatuk A unitok a Pascalban a moduláris programozás alapját képezik. Egy unitban definiálhatunk mindent, amit egy programban is definiálhatunk (konstans, típus, változó, eljárás, funkció, stb). Amikor az adott unitban definiált eljárást vagy konstanst akarom használni, akkor elég csak a unit nevével hivatkoznom a unitra, és minden abban a unitban definiált eljárást, változót, konstanst használhatok anélkül, hogy újra definiálnom kéne. Vagyis a program elején a Uses kulcsszó után fel kell sorolni azoknak a unitoknak a nevét, amelyekben definiált eljárásokat vagy változókat használni akarok. A Turbo Pascal több előre definiált unitot biztosít a programozáshoz. Ezek közül a legáltalánosabbak: − SYSTEM, az összes program és unit automatikusan használja, így sohasem kell megadni − CRT, képernyőkezeléssel kapcsolatos eljárásokat és változókat tartalmaz − GRAPH, grafikus eljárások és változók

gyűjteménye − DOS, a DOS operációs rendszerrel kapcsolatos alacsony színtű eljárások gyűjteménye Saját unitokat is készíthetünk, de ennek szintaktikája egy kicsit eltér a normál programok felépítésétől. Részletesebben lásd a HELP-et. 6. Változók és használatuk Egy változónak van neve, típusa és értéke. A deklarációs részben deklaráljuk a nevét és a típusát VAR kulcsszóval bevezetve. A névvel tudunk hivatkozni a programon belül a változóra, a típus pedig meghatározza, hogy milyen típusú értéket tárolhat a változó. A változók nevüket onnan kapták, hogy a bennük tárolt érték változhat. A programon belül akárhányszor értéket lehet adni egy változónak. Az értékadás a következő formában történhet: valtozonev := érték; A változó neve nem tartalmazhat ékezetes vagy speciális karaktereket, csak betűket, számokat és aláhúzás jelet: „ ”. A következő példa bemutatja a változók használatát:

Program Szampelda; Var Szam : Integer; Begin Szam := 12; WriteLn(Szam); End. A program egyetlen Integer típusú változót használ, amelynek induláskor a 12 értéket adja. A WriteLn utasítás pedig kiírja a képernyőre a Szam nevű változóban tárolt értéket, vagyis jelen esetben a 12-t. Fontos! A Pascal nyelvben minden változónak használatuk előtt értéket kell adni! Nincs alapértékük a változóknak! 7. A Pascal nyelvben használható változók típusai 7.1 Elemi adattípusok Phare kísérleti program 21 Programozás Egész számok: Típusnév Byte ShortInt Word Integer LongInt Comp Méret 1 byte 1 byte 2 byte 2 byte 4 byte 8 byte Értelmezési tartomány 0 . 255 -128 . 127 0 . 65535 -32768 . 32767 -2147483648 . 2147483647 -9,22E-18 . 9,22E+18 Valós számok: Típusnév Single Real Double Extended Méret 4 byte 6 byte 8 byte 10 byte Értelmezési tartomány 1,401E-45 . 3,402E+38 2,939E-39 . 1,701E+38 4,841E-324 . 1,797E+308 3,363E-4932 . 1,189E+4932

Pontosság (tiz.jegy) 7-8 11-12 15-16 19-20 Logikai érték Típusnév Méret Értelmezési tartomány Boolean 1 byte True, False A logikai érték vagy igaz (True), vagy hamis (False) lehet. Karakter Típusnév Méret Értelmezési tartomány Char 1 byte ASCII karakterkészlet (0 . 255) Az értékadásnál a karaktert idézőjelek közé kell tenni: Betu := ’A’; 7.2 Összetett adattípusok 7.21 Szöveg típus Típusnév Méret Értelmezési tartomány String Max 254 byte ASCII karakterkészlet (0 . 255) Karakterek egymáshoz fűzött láncolata, amelynek hossza változhat, de maximum 254 lehet. A deklarációban a maximális hosszúságot rögzíthetjük: Szoveg : String[10]; Ha nem rögzítjük a hosszt , akkor 254 karaktert tárolhatunk egy változóban: Szoveg : String; Értékadásnál szintén idézőjelek közé kell elhelyezni a karaktereket: Szoveg := ’Ez itt a reklám helye!’; Mivel a String típus karakterekből épül fel, ezért külön karakterekre is

hivatkozhatunk egy string-ből: WritLn(Szoveg[5]); A példában a String típusú Szoveg nevű szöveges változó 5. karakterét írja ki a képernyőre Ez a hivatkozás értékadásnál is használható. 7.22 Tömb típus A tömb azonos típusú elemek számozott sorozata. Deklarálásuk: tombvaltozoneve : Array [elsoelemsorszama . utolsoelemsorszama] of tipus; Felhasználásuknál csak a tömb egyes elemeire lehet hivatkozni: tombvaltozoneve [elemsorszama] : = érték; Konkrét példa a felhasználásra, amelyben a többdimenziós tömbökre is van példa: Program TombPelda; Phare kísérleti program 22 Programozás Var Str Tomb : Array [1.9] of String; Byte KetDim Tomb : Array [1.5, 18] of Byte; Begin Str Tomb[1] := ’Első elem’; Str Tomb[2] := ’Második elem’; WriteLn(Str Tomb[1]); Byte KetDim Tomb[1,1] := 4; Byte KetDim Tomb[1,2] := 5; WriteLn(Byte KetDim Tomb[1,1] + Byte KetDim Tomb[1,2]); End. 7.23 Felsorolt típusok Az ilyen típust úgy adjuk meg, hogy valamennyi

lehetséges értékét felsoroljuk. Az értékeket zárójelben, egymástól vesszővel kell felsorolnunk. Az egyes értékeknek egyedieknek kell lenniük, valamint nem lehet szöveges típus Deklarálásuk: Madarak = (fecske, golya, sas, bagoly); Lanyok = (Anna, Jolan, Eva, Adrienn); Napok = (Hetfo, Kedd, Szerda, Csutortok, Pentek, Szombat, Vasarnap); Felhasználásuk: A változó értéke a felsorolt elemek közül csak egy lehet: Madarak := fecske; Lanyok := Eva; Napok := Szerda; Ez az érték nem szöveg, nem is szám, ezért közvetlenül kiíratni sem lehet a WriteLn utasítással. A pascal az egyes elemekhez tulajdonképpen sorszámokat (0, 1, 2, 3, . ) rendel hozzá (nagyság szerint növekvő sorrendben – tehát lényeges a sorrend), és a változó csak a sorszámot tárolja. Ezért is nevezik ezt a típust is sorszámozott típusnak Ezen kívül sorszámozott típusok még az egészek, a logikai, a char típus is, mivel ezek is véges számú rendezett elemek halmazai.

7.24 Résztartomány típus Hasonló az előzőhöz, de itt egy intervallumot, pontosabban annak alsó és felső határát adjuk meg. Tulajdonképpen az intervallum típus egy már létező, sorszámozott típus intervalluma. Példák: Betuk : A.Z; MunkaNapok : Hetfo.Pentek; Az első példa a char típus, a második példa pedig az előző pontban ismertetett Napok sorszámozott típus intervalluma. Az intervallum megadásánál megfigyelhetjük, hogy a Pascal az intervallumok jelölésére két pontot (.) használ 7.25 Halmaz típus A halmaz a matematikai halmaz pascal nyelvbeli megfelelője, némi megszorítással. A halmaz minden eleme azonos típusú kell legyen, valamint egy halmaz elemeinek száma nem haladhatja meg a 256-ot. Definíciójuk: Karakterek : Set of Char; Kisbetuk : Set of ’a’.’z’; Nagybetuk : Set of ’A’.’Z’; Szamjegyek : Set of ’0’.’9’; KetjegyuSzamok : Set of 10.99; A definiált halmazokon értelmezhetők a halmazműveletek, valamint az

értékadás is: Karakterek := [’a’.’e’]; Karakterek := [’c’, ’g’, ’j’, ’v’]; Karakterek := []; {üres halmaz} A halmazműveletekről a 10. fejezetben lesz szó 7.26 Rekord típus A rekord tulajdonképpen egy adatmező, amely különböző típusú változókból, mezőkből állhat, de egy egységként Phare kísérleti program 23 Programozás kezelhető. A változókat a record és az end kulcsszavak között soroljuk fel Deklarálásuk: Datum : record Ev : 1900.2000; Ho : 1.12; Nap : 1.31; end; Hallgato : record VezNev, KerNev : string[20]; SzulIdo : Datum; TanKor : string[4]; TanAtlag : real; end; Lehetőség van arra is, hogy a rekord változói között egy másik rekordot alkalmazzunk. Példánkban így van beágyazva a Hallgato nevű rekord típusú változóba a Datum nevű. Felhasználásuk: A programban egy ilyen rekord típusú változóra a következőképpen hivatkozhatunk: Hallgato.TanKor := ’12F’; WriteLn(Hallgato.TanKor); 7.27 File

típus A file azonos típusú komponensekből álló adatszerkezet, amely nagy mennyiségű adat tárolását teszi lehetővé a háttértáron. A file komponensei lehetnek egyszerű és összetett típusok is Deklarálásuk: AdatFile : File of Char; TextFile : Text; EzisFile : File; A deklarálásnak megfelelően megkülönböztetünk: − tipizált fájlt, melynek elemtípusa pontosan definiált − szövegfájlt, melyet elsősorban szöveges állományok kezelésére használhatunk − nem tipizált fájlt, alacsonyszintű (gyorsabb) fájlkezelés megvalósításához A fájlokkal kapcsolatos műveletekkel egy külön fejezet foglalkozik. 7.28 Egyéb összetett adattípusok Az elméletből tanult további adatszerkezetek is (verem, sor, lista, gráf, bináris fa) megvalósíthatók pascal nyelvben, de ehhez a dinamikus memória kezeléssel, azon belül pedig a mutatók használatával kell tisztában lenni. Ezzel szintén egy külön fejezet foglalkozik. 8. Konstansok és

használatuk A konstansok, mint nevük is mutatja, állandó értéket képviselnek. Definiálásukkor azonnal értéket is kapnak, amelyet a továbbiakban nem lehet módosítani a programon belül. Alapvetően háromféle konstans típusról beszélhetünk: − numerikus − szöveges − tipizált A numerikus konstansok számokat tárolnak, a szövegesek pedig, szöveges adatokat, például: AlsoHatar = 100; FelsoHatar =200; Hiba = ’Hiba történt a program végrehajtás során! A hiba: ’; A tipizált konstansok tulajdonképpen inicializált (értéket kapott) változók, amelyek lehetnek egyszerűek és összetettek a változóknak megfelelően. A tipizált konstansok értékeit ugyanúgy lehet módosítani, mint a változókét! Deklarálásuk: konstansnév : típusnév = érték; Néhány példa, különböző típusú tipizált konstans megadásra: Minimum : Integer = 0; Phare kísérleti program 24 Programozás Maximum : Integer = 9999; Factorial : Array [1.7] of

Integer = (1, 2, 6, 24, 120, 720, 5040); HexDigits : Set of Char = [’0’.’9’, ’a’’f’, ’A’’F’]; Origin : Point = (X: 0.0; Y: 00); 9. Új típusok definiálása és használatuk Ha az előre definiált típusok között nem találunk igényeinknek megfelelőt, mi is készíthetünk újabb típusokat, amelyeket azután változók, illetve konstansok deklaráláshoz is felhasználhatunk. A típusdefiníciónak két módja van: − az új típus már létező típusokból való felépítése vagy − a hozzárendelhető értékek felsorolása Deklarálásuk a type kulcsszó után: újtípusneve = típusdefiníció; A konkrét példákon figyeljük meg a változódeklarálás és típusdeklarálás közötti különbséget: Egesz = Integer; Tomb = Array [1.100] of Byte; Betu = Set of Char; Ketjegyu = Set of 10.99; Ido = record Ev : 1000.2000; Ho : (jan, febr, marc, apr, maj, jun, jul, aug, szept, okt, nov, dec); Nap : 1.31; Ora : 1.12; Perc, Mp : 1.60; End; Evszak =

(Tavasz, Nyar, Osz, Tel); Szamjegy = ’0’.’9’; Az előzőekben definiált típusok mindegyikét felhasználhatjuk változók és konstansok deklarálására: Szam : Egesz; A Tomb, B Tomb : Tomb; Kisbetuk, Magybetuk : Betu; SzulIdo, AktIdo : Ido; Az így definiált változó azután ugyanúgy használható, mint az előző fejezetben definiált változók. 10. Műveletek, kifejezések, relációk A változókkal műveleteket is végezhetünk, így kifejezéshez jutunk. Kifejezésnek nevezzük mindazt, aminek a programban kiszámítható értéke van. A kifejezésben a következők szerepelhetnek: − konstansok − műveletek, más néven operátorok (matematikai (pl. +), logikai (pl <)) − változók − függvények (a pascal beépített függvényei illetve a felhasználó által készített) − zárójelek (a műveletek sorrendjét módosíthatjuk segítségével) − kifejezések Ha a program futása közben kifejezéssel találkozik, kiszámítja az értékét, és azt

használja, ezt nevezik kifejezés kiértékelésnek. A kifejezések igen összetettek is lehetnek, így a kiértékelés során fontos szerepe van a precedenciának, a kiértékelési sorrendnek. A szorzás magasabb prioritású precedenciával rendelkezik, mint az összeadás, ezért kiértékeléskor először a szorzat kerül kiszámításra, és csak azután az összeg. Ezt a kiértékelési sorrendet befolyásolhatjuk a zárójelek segítségével. A kifejezéseknek is van típusa. A típus meghatározza, hogy valami milyen értékeket vehet fel, és milyen műveletek végezhetők vele. A következőkben megvizsgáljuk, hogy az egyes típusokkal milyen műveletek végezhetők 10.1 Számokon végezhető műveletek Az operandusok (amelyekkel műveletet kell végezni) és az eredmény is aritmetikai típusú. A használható operátorok: Műv. Megnev Példa Eredmény + Összeadás Write(12+36); 48 (egész) Kivonás Write(55-19); 36 (egész) Phare kísérleti program 25

Programozás * / div mod and or xor shl shr not Szorzás Osztás Egész osztás Modulus Aritmetikai és (bitenként) Aritmetikai vagy Aritmetikai kizáró vagy Eltolás balra (bitenként) Eltolás jobbra (bitenként) Bitek szerinti negáció Write(4*7); Write(75/2); Write(75 div 2); Write(35 mod 4); Write(50 and 19); Write(21 or 25); Write(5 xor 9); Write(9 shl 3); Write(72 shr 3); Write(not 5); 28 (valós) 37,5 (valós) 37 (egész) 3 (egész) 18 (egész) 29 (egész) 12 (egész) 72 (egész) 9 (egész) -6 (egész) 10.2 Logikai műveletek Az operandusok (amelyekkel műveletet kell végezni) és az eredmény is logikai típusú. A használható operátorok: Műv. Megnev Példa Eredmény and Aritmetikai és (bitenként) Write(True and False); False Or Aritmetikai vagy Write(True or False); True xor Aritmetikai kizáró vagy Write(True or False); True not Bitek szerinti negáció Write(not True); False 10.3 String műveletek Szöveg típusú (String) és karakteres típusú (Char)

változóra egyaránt értelmezhető, az eredmény mindig szöveg típusú: Műv. Megnev Példa Eredmény + Összefűzés Write(’Alfa’ + ’Beta’); ’AlfaBeta’ 10.4 Halmaz műveletek Csak halmazokon értelmezhetőek: Műv. Megnev + Unió Különbség * Metszet In Tartalmazza-e >= Részalmaza-e <= Részalmaza-e Példa A := [1,3,7] + [2,7]; A := [1,3,7] - [2,7]; A := [1,3,7] * [2,7]; A := [3,7] in [1, 2, 3, 7]; A := [3,7] >= [1, 2, 3, 7]; A := [3,7] <= [1, 2, 3, 7]; Eredmény [1,2,3,5,7] [1,3] [7] True False True 10.4 Összehasonlító műveletek Gyakorlatilag az összes típusra alkalmazhatók (kivéve a halmaz), de megkötés, hogy mindkét operandusnak azonos típusúnak vagy legalább kompatíbilis típusúnak kell lennie. Műv. = <> > < >= <= Megnev. Egyenlő Nem egyenlő Nagyobb Kisebb Nagyobb egyenlő Kisebb egyenlő Példa Write(5 = 3); Write(5 <> 3); Write(5 > 3); Write(5 < 3); Write(5 >= 3); Write(5 <= 3); Eredmény

False True True False True False 11. Programozási eszközök, vezérlési szerkezetek 11.1 Értékadás Erről már volt szó, változóknak adhatunk értéket: SzamValt := 12; Phare kísérleti program 26 Programozás 11.2 Adatbevitel és adatkiírás Alapesetben a képernyőre tudunk kiírni, illetve a billentyűzetről tudunk beolvasni valamit. Kiírás Eddig kétféle kiíró utasítással találkozhattunk, a WriteLn-el és a Write-al. A kettő között mindössze annyi a különbség, hogy a WriteLn a kiírt adatok után új sort kezd, így a következő kiíró utasítás eredménye már a következő sor elején kezdődik. Beolvasás A ReadLn(i) utasítás szolgál arra, hogy az i változóba a billentyűzetről értéket olvassunk be. Arra azonban mindig figyelni kell, hogy a változó típusának megfelelő adatot írjunk be, különben hibaüzenetet kapunk. Ha csak egy karaktert szeretnénk beolvasni a billentyűzetről, akkor használható még a ReadKey függvény

is, mely a Crt unitban van definiálva. A billentyűzet lenyomásának érzékelésére pedig a KeyPressed függvény használható, mely szintén a Crt unitban van definiálva. A következő példaprogram beolvas két számot, majd az összegüket kiírja a képernyőre: Program Osszeg; Var A, B : Integer; Begin Write(’Írd be az első számot: ’); ReadLn(A); Write(’Írd be a második számot: ’); ReadLn(B); WriteLn(’A két szám összege: ’, A + B); End. 11.3 Feltételes programvégrehajtás Az utasítás vagy utasítás blokk csak adott feltétel teljesülése illetve nem teljesülése esetén hajtódik végre. Formái: If feltétel Then utasítás; If feltétel Then Begin utasítás; utasítás; End; If feltétel Then utasítás1 Else utasítás2; If feltétel Then Begin Utasítás1; utasításn Else Utasítás1; utasításn End; A feltétel valamilyen logikai kifejezés eredménye kell legyen. Ha ez IGAZ, akkor a Then utáni utasítás vagy utasítások (Begin End

közé zárva) hajtódnak végre. Ha ez HAMIS, akkor az Else utáni utasítás vagy utasítások hajtódnak végre Amennyiben nincs Else ág, akkor az If utáni utasítással folytatódik a végrehajtás. Figyeljük meg, hogy az Else előtt nincs pontosvessző! A következő példa egy változó értékétől függően más-más szöveget ír ki a képernyőre: If (Ivalt>10) Then WriteLn(’Értéke nagyobb, mint 10’) Else WriteLn(’Értéke kisebb egyenlő, mint 10’); Az If Then szerkezet egymásba is ágyazható, ami azt jelenti, hogy az utasítás helyén egy újabb If utasítás található és ez Phare kísérleti program 27 Programozás tetszőleges mélységben folytatható. Ilyenkor arra kell vigyázni, hogy áttekinthető legyen a forrásprogram Ebben az esetben célszerű minden utasítást utasítás blokkban elhelyezni (Begin End). 11.4 Esetszétválasztás Segítségével egy változó vagy kifejezés különböző értékéhez különböző utasítások

rendelhetők hozzá. Formái: Case változó Of érték1: utasítás1; érték2: utasítás2; . értékn: utasításn; End; Case változó Of érték1: utasítás1; érték2: utasítás2; . értékn: utasításn; Else utasítás; End; Itt is, mint mindenhol az utasítások helyén utasítás blokk is állhat (Begin End közé zárva). Ha a változó aktuális értéke nem egyezik egyik felsorolt értékkel sem, akkor egyik utasítás sem kerül végrehajtásra. Ha van Else sor is, akkor az Else utáni utasítás hajtódik végre. A következő példa szövegesen írja ki egy változó értéket: Write(’A változó értéke ’); Case Ivalt Of 1: WriteLn(’egy’); 2: WriteLn(’kettő’); 3: WriteLn(’három’); 4: WriteLn(’négy’); 5: WriteLn(’öt’); 6: WriteLn(’hat’); 7: WriteLn(’hét’); 8: WriteLn(’nyolc’); 9: WriteLn(’kilenc’); 10: WriteLn(’tíz’); Else WriteLn(’nagyobb, mint 10!’); End; 11.5 Ciklusszervezés A ciklusszervezés során adott

programrész ismételt végrehajtása a cél. Ezt a Pascal nyelvben is többféleképpen valósíthatjuk meg. Adott számú ismétlés: For változó := kezdőérték To végérték Do utasítás; A változó értéke egyenként felveszi a kezdőérték és a végérték közötti értékeket, és minden értéknél végrehajtásra kerül az utasítás is. A változó értéke az utasításban is felhasználható Az utasítás helyén utasítás blokk is állhat A következő példa 1-től 10-ig kiírja a számokat: For I := 1 To 10 Do Writeln(I); Elöltesztelő ciklus: While feltétel Do utasítás; Az utasítás vagy utasítások mindaddig végrehajtásra kerülnek, amíg a feltétel IGAZ. Ha a feltétel a végrehajtás kezdeténél HAMIS, akkor az utasítás vagy utasítások egyszer sem kerülnek végrehajtásra. Az előző példa elöltesztelő ciklussal: I := 1; While (I<=10) Do Begin Phare kísérleti program 28 Programozás WriteLn(I); I := I+1; End; Hátultesztelő

ciklus: Repeat utasítás1; utasítás2; . utasításn; Until feltétel; Az utasítások mindaddig végrehajtásra kerülnek, amíg a feltétel HAMIS. Ebben az esetben nem szükséges a Begin End használata, a Repeat Until szintén utasítás blokkot definiál. Az előző példa elöltesztelő ciklussal: I := 1; Repeat WriteLn(I); I := I+1; Until (I>10); 11.6 Eljárások Nagyobb feladatot célszerű lépésekre bontani. Továbbá, vannak olyan tevékenységek, melyeket a programban több helyen is el kell végezni. Az ilyen rész-tevékenységeket külön egységbe foglalhatjuk, ezek neve alprogram (subrutin) vagy eljárás (procedure). Az eljárásoknak azonosítójuk van, és a deklarációs részben adjuk meg őket a következőképpen: Procedure eljárásnév(paraméterlista); az eljárás saját deklarációs része Begin az eljárás utasításai {más néven az eljárás törzse} End; Mint látható, a saját deklarációs rész miatt az eljárás valóban önálló

programként viselkedhet. A saját deklarációs részben nem szerepelhet a Program és a Uses utasítás. Az eljárásokat a nevükkel indíthatjuk el a főprogramból vagy más eljárásokból (természetesen csak akkor, ha az eljárás deklarációja megelőzte az eljárásra való hivatkozást). Ez az eljáráshívás Így az eljárások pontosan úgy működnek, mint a Pascal saját utasításai. Ha úgy tetszik, a Pascal utasításkészletét bővítettük, amikor egy azonosítóhoz hozzárendeltünk egy tevékenységet. Az eljárásokon belül definiálhatunk újabb eljárásokat is, de ezeket csak a fő eljáráson belül használhatjuk. 11.61 Globális és lokális változók Az előbb láthattuk, hogy az eljárásoknak saját deklarációs részük is lehet. Így az is elképzelhető, hogy két különböző típusú változó azonos nevet kap, az egyiket a főprogramban, a másikat az eljárásban deklaráljuk. Ezt a problémát a Pascal nyelv a globális és lokális

változók segítségével oldja meg. A globális változók a főprogramban definiált változók. Ez azt jelenti, hogy a programban bárhol, bármelyik eljáráson belül hozzáférhetünk az értékéhez, illetve módosíthatjuk az értékét. A lokális változók az eljárásokon belül definiált változók. Ezek a változók csak az eljáráson belül használhatók, a főprogram többi részében elérhetetlenek. Abban az esetben, ha a főprogramban és az eljárásban is definiáltunk egy azonos nevű változót, akkor az eljáráson belül a lokális változót tudjuk használni, az eljáráson kívül pedig csak a globális változót. Az eljárás belsejében deklarált saját, avagy lokális változók kívülről, vagyis az eljárást hívó programból láthatatlanok: az eljárás hívásakor keletkeznek, és az alprogram lefutása után megszűnnek. Ha a főprogramnak van azonos nevű változója, azt a Pascal az eljárás működésének idejére elraktározza. 11.62

Paraméterek és kezelésük, cím szerinti és érték szerinti paraméter átadás Az eljárások deklarálásakor egy paraméterlistát is megadhatunk. A paraméterlista a változódeklarációhoz hasonlóan a paraméterek azonosítóját és típusát tartalmazza. Példa egy karaktert adott helyre kiíró eljárásra: Procedure KiirXY(x, y : Integer; c : Char); Phare kísérleti program 29 Programozás Begin GotoXY(x, y); Write(c); End; A paraméterek az eljárásban lokális változókként viselkednek, azzal a különbséggel, hogy nem az eljáráson belül kapnak értéket, hanem az eljárás hívásakor, kívülről. Var I : Integer; Begin For I := 1 To 10 Do KiirXY(10, I, ’*’); End. Például amikor az I értéke 3, az eljárás hívásakor az egyes paraméterek értéke: x=10, y=3, c=* lesz. Vagyis, eljáráshíváskor a hívó utasításban lévő értékeket veszik fel az eljárás paraméterei. Ez az érték szerinti paraméterátadás. Előfordul, hogy az

eljárásnak változókat szeretnénk átadni, és ezekkel kell valamilyen műveletet végezni, tehát a hívó program változóit kell változtatni. Ezt megoldhatjuk úgy is, hogy globális változókat használunk, melyeket tud kezelni az eljárás, de akkor a program áttekinthetetlenebb lesz, mert az eljárás önállósága megszűnik. Erre a célra használható a cím szerint paraméterátadás, más néven a változóparaméterek. Ekkor paraméterként nem értéket adunk át, hanem változót, és ezt a paraméterlistában Var szóval jelöljük: Procedure Csere(Var a,b : Integer); Var m : Integer; Begin m := a; a := b; b := m; End; Var p, q : Integer; Begin p := 8; q := 4; Csere(p, q); WriteLn(p, q); End. Ez a program a 4,8 számokat írja ki. Ha a var szócskát nem írtuk volna a paraméterlista elejére, a főprogram változóival semmi nem történt volna, csak az eljárás lokális változóiban cseréltük volna fel az értékeket. A var szó hatására a következő

történik: eljáráshíváskor létrejön az eljárás lokális a és b változója, de ezek a változók ugyanarra a memóriacímre mutatnak, mint a főprogram p és q változói. Tehát akármilyen műveleteket végzünk az a és b változókkal, ugyanaz fog történi a főprogram p és q változóival. Így a Csere eljárást nem is lehet számokkal meghívni, csak integer típusú változókkal. Használhatunk változó- és közönséges paramétereket egyszerre is: Procedure Valami(s : String; var c : Integer); A deklarációnál s közönséges, c pedig változóparaméter. A Pascal több utasítása is használ változóparamétert, pl az Initgraph. 11.7 Függvények A függvények pontosan úgy működnek, mint az eljárások, azzal a különbséggel, hogy visszatérési értéket is szolgáltatnak. A visszatérési értéket a függvény törzsében a következő utasítással állíthatjuk be: függvénynév := érték; A függvény deklarálásakor jelezni kell a

visszatérési érték típusát, mely csak elemi típus lehet. Function függvényneve(paraméterlista) : típus; A függvény ezeken kívül ugyanúgy működik, mint egy eljárás. Nem elegáns azonban, ha a függvény a visszatérési érték kiszámításán kívül más tevékenységet is végez. Ilyen esetekben inkább használjunk eljárást, és a visszatérési értéket változóparaméterrel adjuk vissza a hívó programnak. A Pascalban megfelelő beállítás esetén a függvényeket eljárásként is meghívhatjuk: ekkor csak a függvény mellékhatása Phare kísérleti program 30 Programozás jelentkezik. Például a Readkey függvényt utasításként használva a program egy billentyű lenyomásáig várakozik Példa a függvények deklarációjára és alkalmazásukra: Function Kob(a : Real) : Real; Begin Kob := a * a a; End; Begin WriteLn(Kob(4)); End; 12. Állománykezelés Gyakran szükség lehet arra, hogy a memóriában lévő adatokat lemezre írjuk, vagy

lemezen lévő adatokat olvassunk be. A lemezen lévő adatok fájlokban helyezkednek el. Egy adatszerkezet működését a benne lévő adatok típusán kívül az is meghatározza, hogy miképpen tudunk bele adatot írni, vagy belőle adatot olvasni. Noha egy fájl minden esetben byte-ok sorozata, a fájlokat háromféle módon kezelhetjük: − szöveges fájlként − tipizált fájlként − nem tipizált fájlként Az azonosságok a különböző fájlkezelési módszerek esetén: − az állományok kezeléséhez is szükség lesz egy változóra, amelyet ugyanúgy kell deklarálni, mint a változókat − a fájlok használata előtt a változót hozzá kell rendelni egy fizikai fájlhoz, ezt a hozzárendelést végzi az Assign eljárás, pl.: Assign(F, ’C:PRGADAT.DAT’); az F változóhoz az ADAT.DAT állományt rendeltük hozzá − mielőtt olvasnánk vagy írnánk az állományba, meg kell nyitni Reset(F) – megnyitjuk a fájl a további műveletekhez ReWrite(F) – új

fájlt hoz létre, illetve törli az előző ilyen nevű fájlt, majd megnyitja Append(F) – továbbírásra nyitjuk meg (csak szöveges fájlok esetén alkalmazható) − olvasás a fájlból – Read eljárás − írás a fájlba – Write eljárás − minden megnyitott fájlhoz fájlmutató van hozzárendelve, mely a következő fájl elemre mutat, és automatikusan változik a Read, Write hatására, de mi is állíthajuk a Seek eljárás segítségével − lekérdezhető a fájlmutató aktuális értéke a FilePos függvénnyel − megtudhajuk, hogy a fájlmutató a fájl végén áll-e az Eof függvénnyel − a munka végeztével az állományokat le kell zárni a Close eljárással 12.1 Szöveges állománykezelés A szöveges állományok kifejezetten szövegek tárolására használhatók. A szövegek betűkből állnak és értelmezve van a sor vége is. Gyakorlatilag a szövegfájl sorokból épül fel, a sor vége jel pedig az ENTER Szöveges fájlok esetén a Reset-el

történő megnyitás csak olvasást tesz lehetővé. Nem alkalmazhatók a Seek, FilePos, FileSize, Truncate eljárások. Deklarálásakor a Text típusnevet kell használni. Szövegfájlból olvasni célszerűen a ReadLn, írni pedig a WriteLn utasítással lehet úgy, hogy első paraméternek a fájlhoz hozzárendelt változót kell megadni. A következő példaprogram megjeleníti az ALMA.TXT nevű szöveges fájl tartalmát a képernyőn: Var F : Text; s : String; Begin Assign(F, ’ALMA.TXT’); Reset(F); While not Eof(F) Do Begin ReadLn(F, s); WriteLn(s); End; End. Phare kísérleti program 31 Programozás 12.2 Tipizált állománykezelés A tipizált állománykezelés lényege, hogy pontosan definiáljuk (tipizáljuk) az állományok felépítését. Már a változó definíciójával meghatározzuk, hogy milyen alapelemekből állnak. Pl: F : File Of Byte; {az állományt bájtonként lehet olvasni és írni} F : File Of Array [1.100] of Integer; {a fájl legkisebb

kezelhető eleme egy 100 elemű Integer tömb} A következő példa egy tipizált állomány feltöltését mutatja be: Type AdatRecTipus = Record Nev : String[20]; Szul : Integer; End; Var F : File of AdatRecTipus; r : AdatRecTipus; Begin Assign(F, ’NYILV.DAT’); Reset(F); Repeat Write(’Név: ’); ReadLn(r.Nev); If r.Nev <> ’*’ Then Begin Write(’Született: ’); ReadLn(r.Szul); End; Until r.Nev = ’*’; Close(F); End. 12.3 Nem tipizált állománykezelés Ebben az esetben általában közömbös számunkra az állomány szerkezete, a hangsúly a gyors hozzáférésen van. Ebben az esetben az állományokat blokkonként olvassuk és írjuk. A kezelendő record méret a Reset utasítás segítségével állítható be. Nem alkalmazhatók rájuk a Read és Write eljárások, helyettük a BlockRead és BlockWrite eljárásokat kell használnunk. A következő példa egy egyszerű állománymásolást végez: Program CopyFile; Var InFile, OutFile: File; NumRead,

NumWritten: Word; buf: array[1.2048] of Char; Begin Assign(InFile, ParamStr(1)); Reset(InFile, 1); Assign(OutFile, ParamStr(2)); Rewrite(OutFile, 1); WriteLn(Másolok , FileSize(InFile), bájtot.); repeat BlockRead(InFile, buf, SizeOf(buf), NumRead); BlockWrite(OutFile, buf, NumRead, NumWritten); until (NumRead = 0) or (NumWritten <> NumRead); Close(InFile); Close(OutFile); End. 13. Dinamikus memóriakezelés, mutatók és használatuk A Pascal hiányosságának tűnik az a megkötés, hogy a változókat előre deklarálni kell. Így a program elején Phare kísérleti program 32 Programozás deklarálhatunk egy tömböt, és a program futása közben derül ki, hogy a szükséges adat (pl. egy fájlból beolvasott hosszú számsorozat) nem fér bele. Ez mindig olyankor fordul elő, amikor nem ismerjük előre a feldolgozandó adat mennyiségét. Ezen segít a Pascal azon lehetősége, hogy a program futása közben is foglalhatunk le memóriát változóknak - ezek

lesznek a dinamikus változók, szemben a program deklarációs részében előre megadott statikus változókkal. Dinamikus változók használatánál a programozónak az eddiginél többet kell foglalkozni a memóriakezeléssel, melyet egyébként a Pascal automatikusan végez. A változó létrehozásakor le kell foglalni egy megfelelő méretű memóriaterületet, és gondoskodni kell annak felszabadításáról, ha a változóra már nincs szükség. Ehhez tudni kell, hogy a dinamikus változó hol helyezkedik el a memóriában, és mennyi helyet foglal le. A mutató olyan változó, mely a memória adott helyére mutat. Két fajtáját különböztethetjük meg, a típusos mutatókat és típus nélküli mutatókét. A mutatók segítségével lehet kezelni a dinamikus változókat A mutatók speciális értéke a NIL, ami azt jelzi, hogy a mutató éppen nem mutat sehová. 13.1 Tipizált mutatók A tipizált mutatók lényege, hogy deklarációjuknál rögzítjük, hogy milyen

típusú adatra fognak mutatni. A Pascal ezt megjegyzi, és a helyfoglalás az ilyen típusú adatok részére egyszerűbb. Deklarálásuk: változóneve : ^típusnev; Vagyis a változók deklarálásától annyiban különbözik, hogy a típusnév előtt a hatvány jelnek (^) kell szerepelnie, pl.: I Mut : ^Integer; Az így definiált I Mut nevű változó azonban nem Integer értéket tartalmazhat, hanem csak egy memória címet vagy a NIL értéket. Megtehetjük azonban azt, hogy egy Integer típusú változó értékének címét adjuk meg értékül a mutatónak az Addr függvény segítségével. Ezután az Integer változó ugyanúgy kezelhető a mutatón keresztül is, mint a normál változó, de a ^ jelre ilyenkor is szükség van. Ezzel jelezzük, hogy a mutatott értékre van szükségünk és nem a mutató változó értékére: Var I Valt : Integer; I Mut : ^Integer; Begin I Valt := 12; I Mut := Addr(I Valt); WriteLn(I Valt, ’ ’, I Mut^); I Mut^ := 35; WriteLn(I

Mut^); End. Ha önálló helyet szeretnénk a memóriában egy Integer típusú változónak, azt a következőképpen tehetjük meg a mutatók segítségével: New(I Mut); Hatására a memóriában lefoglalásra kerül egy Integer változónak szükséges hely (feltéve, ha az I Mut Integer típusú mutató), majd az I Mut értéke a lefoglalt terület kezdőcíme lesz. Innentől az I Mut^ formával úgy kezelhető, mint egy normál változó. A különbség mindössze annyi, hogy program vagy eljárás vége előtt az előbb lefoglalt memóriaterületet fel is kell szabadítani a Dispose eljárással: Dispose(I Mut); Nézzünk egy példát dinamikus változó létrehozására: Var P : ^Integer; Begin New(p); ReadLn(p^); WriteLn(p^); Dispose(p); End. A példában p^ egyszerű változóként viselkedett, melyet a program futása közben hoztunk létre. A következő példa létrehoz 2, 150 elemű String-ből álló tömböt, így a pointerek használatával máris túlléptük a

statikus memóriakezelés 64 Kbyte-os korlátját: Type Phare kísérleti program 33 Programozás Tomb = Array[1.150] Of String; Var p, q : ^Tomb; i: Integer; Begin New(p); New(q); For i := 1 To 150 Do Begin p[i] := ’Egyik szöveg’; q[i] := ’Másik szöveg’; End; Dispose(p); Dispose(q); End. Itt p^ és q^ olyan, mint két 150 elemű tömb. A p és q pointereket közvetlenül nem használjuk A statikus memóriában csak a pointerek helyezkednek el, egy pointer pedig (mivel tartalma csak egy memóriacím) alig foglal memóriát. 13.2 Típus nélküli mutatók Deklarálásuk: változóneve : Pointer; Mint neve is mutatja, az így definiált mutatóról nem tudhatjuk, hogy milyen típusú adatra mutat. Pontosabban bármilyen típusú adatra mutathat. Ebből következően a New és Dispose eljárás sem használható Helyettük a GetMem és FreeMem eljárást használhatjuk. Mindkettőnek még azt is meg kell mondani, hogy mekkora memória területet foglaljon le, illetve

szabadítson fel. Minden mutató típusra igaz, hogy a memóriában a lefoglalásra felhasználható memóriaterület korlátozott. A szabad memóriaterületet a MemAvail és MaxAvail függvények segítségével ellenőrizhetjük. A MemAvail az összes szabad terület méretét adja vissza, míg a MaxAvail a legnagyobb szabad blokk nagyságát. Phare kísérleti program 34