Programozás | Pascal » Turbo Pascal tételek

1. A1 tétel Elemi programozási tételek III.: a lineáris keresés és a logaritmikus keresés A lineáris keresés tétele Általános feladat: Rendelkezésre áll egy N elemű sorozat, egy, a sorozat elemein értelmezett T tulajdonság. Olyan algoritmust kell írni, amely eldönti, hogy van-e T tulajdonságú elem a sorozatban, és ha van, akkor megadja a sorszámát. 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 Ha VAN akkor SORSZ:=I Eljárás vége. Logaritmikus keresés Általános feladat: adott egy rendezett N elemű sorozat és egy keresett elem (X). Olyan algoritmust kell írni, amely eldönti, hogy szerepel-e a keresett elem a sorozatban, s ha igen, akkor megadja a sorszámát. Algoritmus: Eljárás A:=1 : F:=N Ciklus K:=INT((A+F)/2) Ha A(K)<X akkor A:=K+1 Ha A(K)>X akkor F:=K-1 amíg A<=F és A(K)<>X Ciklus vége VAN:=A<=F Ha VAN akkor SORSZ:=K Eljárás vége. 1. A2 tétel A

strukturált programozás jellemzői. A modul fogalma, és tulajdonságai a Turbo PASCAL-ban. A PASCAL program szerkezete Egy programot akkor nevezünk strukturáltnak, ha nem tartalmaz feltétel nélküli (GOTO) ugrást, és algoritmusa teljes mértékben megvalósítható véges mélységig „egymásba skatulyázott”, egyszerű és összetett program struktúrákkal (szerkezetekkel). Ha a Turbo PASCAL-ban nem használunk címkével jelölt utasítást, és arra történô ugrást, akkor strukturált programot nyerünk. Ehhez a programot modulárisan kell felépítenünk. Minden többször ismétlôdô programrészt önálló modulként (egység, eljárás, függvény) kell deklarálni, és a fô vagy más modulba beépítve, nevével (ha van, ezt követô paraméterekkel) kell hívni. A Turbo PASCAL-ban a moduláris programozás alapját az unitok képezik. Ezek önállóan fordítható, de logikailag egymáshoz kapcsolható programegységek, modulok. Lehetővé teszik, hogy egy

programban felhasználhassunk már létező objektumokat anélkül, hogy be kellene másolni azokat a forrásprogramba. A Pascal program három fő részből áll: programfej definíciós ill. deklarációs rész programtörzs. A Pascal program szerkezete: {programfej} {globális hatású fordítási direktívák} program programnév; {deklarációs rész} {lokális hatású fordítási direktívák} uses {a használt unit könyvtárak felsorolása}; label {címkék deklarálása}; const {konstansok deklarálása}; type {típusok deklarálása}; var {változók deklarálása}; procedure eljárásnév (paraméterek); {deklarációk} begin {az eljárás történetének utasításai} end; function függvénynév (paraméterek); {deklarációk} begin {A függvény törzsének utasításai} függvénynév:=utasítás; {a függvény eredménye} end; {a főprogram blokkja} begin {a főprogram törzsének utasításai} end. 1. B tétel Adatállomány kezelése: létrehozás, megnyitás,

módosítás a FoxPro 2.5-ben CREATE: Új adatbázis létrehozása. CREATE [<adatbázisnév>|?] <adatbázisnév>-az új, üres adatbázis neve. Ha nem adjuk meg, vagy a ?-et alkalmazzuk, akkor a nevet az adatbázis létrehozásakor adhatjuk meg. Az adatbázis a mezők nevének, típusának és méretének definiálásával jön létre. A struktúra kialakítása után azonnal tartalommal is feltölthető. CREATE TABLE: Adatbázis létrehozása megadott mezőkkel. CREATE TABLE | DBF <dbf -név> (<mezőnév1> <típus> [(<hossz> [,<tizedesek>])] [,<mezőnév2>.])|FROM ARRAY <tömb> <dbf-név>-a létrehozandó adatbázis neve. <mezőnév1>[,<mezőnév2>]-az új adatbázis mezőnevei. <típus> [<hossz> [,<tizedesek>]]-a <típus> egy karakter, amely a mező típusát határozza meg; a <hossz> a mező hossza, a <tizedesek> a numerikus mezők esetében a tizedesjegyek száma.

<tömb>-annak a tömbnek a neve, amely tartalmazza a létrehozandó adatbázisneveit, azok típusát, hosszát és a numerikus mezők tizedesjegyeinek számát. USE: Egy adatbázis és kapcsolóállományai megnyitása. USE [<adatbázisnév|?>][IN <munkaterület>] [AGAIN] [INDEX <indexállomány lista> | ? [ORDER][<kifN> | <.idx indexállomány> | [TAG]<tag -név> [OF <.cdx állomány>] [ASCENDING | DESCENDING]]]] [ALIAS <aliasnév>] [EXCLUSIVE] [NOUPDATE] <adatbázisnév>-adatbázis neve. Ha nem adjuk meg, vagy a ?-et alkalmazzuk, akkor a nevet a dialógusablakban adhatjuk meg. IN <munkaterület> -a paraméter megadása esetén az adatbázis egy nem használt munkaterületen megnyitható. AGAIN-ugyanaz az adatbázis ennek a paraméternek a megadásával egyidejűleg több munkaterületen is megnyitható. INDEX <indexállomány lista>|?-az adatbázishoz megnyitni kívánt indexállományok listája.

ORDER<kifN>-az indexállomány lista> sorrendjének megfelelő szám, amely szerint a rendezettséget kívánjuk. ORDER [ [TAG]<tag-név> [OF <.cdx állomány>] ]-a „master” indexek kijelölésének különböző módjai a megfelelő állomány nevére való hivatkozással. ASCENDING | DESCENDING-az ORDER-ben megadott index szerint megnyitott állomány rendezettsége növekvő vagy csökkenő legyen. ALIAS <aliasnév>-a munkaterülethez definiált azonosító név. EXCLUSIVE-megadása esetén a hálózatban az adatbázis kizárólagos használatra lesz megnyitva. NOUPDATE-az adatbázis módisításának letiltása. MODIFY STRUCTURE: Adatbázis struktúrájának módosítása. 2. A1 tétel Algoritmus fogalma, tulajdonságai, felépítése, algoritmusleíró eszközök. Az algoritmus fogalma: Az algoritmus több, esetleg végtelen sok azonos jellegű, egymástól csak a kiindulópontban különböző feladatok megoldására használható eljárás,

amelyek során utasításszerűen előre meghatározott lépéseket kell adott sorrendbe elvégeznünk. Az algoritmus készítésénél első lépés, hogy elkészítsük a problémamegoldás tervét. Algoritmusleíró eszközök: - szöveges leírás - blokkdiagram - struktogram Első lépésnél fentről lefelé módszerrel célszerű készíteni, a megoldásnál pedig lentről felfelé. A tervet átültetjük konkrét programozási nyelvekre. A feladat lépéseit a különféle utasítások jelentik: - I/O utasítás - értékadó utasítás - felvételvizsgáló- vagy tesztelő utasítás - adatátalakító utasítás Az algoritmus tulajdonságai a., Meg kell adni a végrehajtandó műveleteket, azaz le kell írni, hogy mely adatokkal milyen átalakítást kell végezni. Valamint azt, hogy az eredményül kapott adatokat a tevékenység későbbi fázisában fel kell használni, alkalmazni. b., Meg kell fogalmazni azokat a különleges eseteket, melyek az átlagosnál eltérő

megoldást igényelnek. c., Meg kell adni a műveletek sorrendjét az összes esetre vonatkozólag. d., Csak oly an instrukciókat tartalmazzon, amely egyértelműen hajtható végre. e., Mindezeket az információkat a végrehajtó számára érthető és egyértelműen értelmezhető formában, szimbólumrendszerben kell közvetítenie. Felépítése a., Az algoritmust a végrehajtó számára szóló utasításokból építjük fel. Az utasítások egyik típusában megadjuk az elvégezendő műveleteket és azokat az adatokat, amelyekkel ezeket el kell végezni. Továbbá a kiszámított eredmények megőrzésének módját. Ezeket az utasításokat adatátalakító utasításoknak nevezzük. b., Az utasítások második típusában, amelyeket tesztelő utasításoknak nevezünk, a végrehajtót egy igaz vagy hamis voltának megállapítására szólítják fel. A kijelentés idegen szóval predikátum megfogalmazásánál megadjuk azokat az összefüggéseket, melyeknek

teljesülését az adatoktól megkívánjuk, ahhoz, hogy a vizsgálatot követően egy meghatározott következő utasításokkal folytathassuk a megoldási tevékenységet. Az algoritmus leíró eszközei 1., Szekvencia: sorban egymás után való végrehajtás 2., Elágazás: elágazik, de továbbra is előre megy 3., Ciklus: elágazik, és visszamegy egy időre Stuktogram 1., utasítás terminális szimbólumok utasítás 2., 3., i utasítás /n ut. utasítás ut. Feltétel tesztelő doboz ciklusmag értékadó utasítás Blokkdiagramm: 1., 2., utasítás utasítás i felt. utasítás n utasítás 3., utasítás utasítás Szöveges leírás: 1., Ha (feltétel) akkor (utasítás) különben (utasítás) elágazás vége 2., legyen legyen . utasítások 3., Ciklus eleje tedd addig amíg (feltétel) utasitás utasítás Ciklus vége. Ciklus eleje tedd utasítás utasítás tedd addig amíg Ciklus vége. 2. A2 tétel Struktúrák ábrázolása a Turbo

PASCAL-ban és a FoxPro-ban Egy programot akkor nevezünk struktúrálnak, ha nem tartalmaz feltétel nélküli (GOTO) ugrást, és algoritmusa teljes mértékben megvalósítható véges mélységig „egymásba skatulyázott”, egyszerû és összetett program struktúrákkal (szerkezetekkel). A ma ismert, és használt programnyelvek legtöbbje megfelel ennek a kritériumnak. Igy például ha a QuickBASIC - ben Turbo C - ben Turbo PASCAL - ban nem használunk cimkével jelölt utasítást, és arra történô ugrást, akkor struktúrált programot nyerünk. Ehhez a programot modulárisan kell felépítenünk Minden többször ismétlôdô programrészt önálló modulként (egység, eljárás, függvény) kell deklarálni, és a fô vagy más modulba beépítve, nevével (ha van, ezt követô paraméterekkel) kell hívni. Az adatbázis kezelô xBASE - kompatibilis nyelvek (dBASE, Clipper, FoxPro stb.) eleve struktú-ráltak, mert a programban nem tesznek lehetôvé feltétel

nélküli ugrást. A GO vagy GOTO parancsnak itt teljesen más funkciója van, az adatfile rekordjaira való pozícionálást szolgálja. Az egyszerû és összetett programstruktúrák, és maga a teljes struktúrált program is, csekély eltéréstôl eltekintve, programnyelvtôl független módon ábrázolhatók az úgynevezett Struktogramok (struktúra ábrák) segítségével. A struktogrammal ábrázolt algoritmus jól áttekinthetô, lehetôvé teszi a program gondos megtervezését éppúgy, mint a kész program tesztelését, dokumentálását. Programnyelvôl nem függô struktogramok - adatátalakító, vagy döntési doboz : egyszerû struktúrák, másnéven szekvenciák (értékadás, ki és bevitelek, eljárás és függvényhívások) ábrázolása. - kétirányú elágazásos tesztelô doboz : az IF kulcsszóval kezdôdô feltételes szerkezetek ábrázolása. <feltétel> i /n - elôltesztelô doboz : elôltesztlô For, illetve While Do ( DO WHILE ) ciklusok

ábrázolása. <ciklusfeltétel(ek)> Programnyelvôl függô struktogramok - többirányú elágazásos tesztelô doboz : PASCAL-ban Case <hasonlító kifejezés> Of . szerkezet ábrázolása é1 : <hasonlító kifejezés> é2 : é3 : else FoxPro-ban DO CASE . CASE END CASE szerkezet ábrázolása <feltétel1> <feltétel2> hátultesztelô doboz : ciklusszerkezet ábrázolása. PASCAL-ban <feltétel3> Otherwise Repeat Until . <feltétel> hátultesztelô <ciklusfeltétel> - minôsítô doboz : With <hatáskör> Do PASCAL-ban <hatáskör> minôsítô utasítás szerkezet ábrázolása. 2. B tétel Adattipusok FoxPro 2.5-ben Típuskonverziók Mezôtípusok: Karakteres (Character),(max. 254 byte) • nyomtatható, billentyûzetrôl beírható szöveg (minden ASCII karakter) szerepelhet benne • max. 254 karakter hosszú • olyan adatok tárolására alkalmazható amelyekkel matematikai

mûveleteket nem végezhetünk • • • • • Numerikus (Numeric), (max. 20 számjegy) elôjeles számok ábrázolására alkalmazható olyan adatokat tárolunk benne amellyel matematikai mûvelet(ek)et végzünk 16 jegynél hosszabb számokat normál alakban tárolja mûveleteket és fv. kiértékeléseket 16 jegy pontosságra végzi az összehasonlításokat 14 jegy pontosságra Lebegôpontos numerikus (Float), (max. 20 számjegy) Dátum (Date),(8 byte) • hossza 8 karakter ebbôl 6 a tényleges és 2 / jelet az amerikai rendszer szerint a gép generál (hónap / nap / év) • dátumfajták (set date to . és set century on (évszázad jelzés) paranccsokkal állíthatók be): ansi - magyar british - angol french - francia german - német italian - olasz merican - amerikai • Mûveletek végezhetôk a dátum típ. változókkal Pl kivonás külön az évre, hónapra vagy a napra • • • • Logikai (Logical),(1 byte) hossza egyetlen karakter típusérték halmaza (T,

t, Y, y, F, f, N, n) értékeket veheti fel minden olyan információ tárolására, amely csak két értékû lehet ha nincs értékadás van alapértelmezése. Feljegyzés (Memo) (Üresen 10 karakter) • külön állományba tárolódik DBT kiterjesztéssel (csak a használt lemez mérete szab határt). • ha azt az állományt megnyitjuk, amelyhez memo típusú adat létezik, akkor ez az állomány is megnyilik (programozás közben módosítható). • adatállomány írásakor megjeleníthetô tartalma : ^PgDown eltüntethetô : ^PgUp • memo típusú adattal adatbázis kezelô feladatok nem végezhetôk ! Általános (General) / Grafikus (Picture), (Üresen 10 karakter) • Windows objektumok befogadására (OLE technika) hozták létre. • Adatbevitel programból (APPEND GENERAL paranccsal) vagy keresztül vihetô be Clipboardon Adatbázis allományon kívül tárolt adatok (konstansok) • karakterlánc pr. szövegben ( ”xxx” vagy ‘yyy’ alakban ) • numerikus

tipusú konstans • logikai konstans • dátum konstans FoxPro változók: 1., Adatfile : rekordjainak mezôi (7 típus) fix adattárolást végeznek 2., Memóriaváltozó : program futás köz ben átmeneti adattárolás célját szolgálja • • • • Memória változók: nevûk legfeljebb 10 karakter (betû,szám,aláhuzás; betûvel kezd.) memória változók és adatbázis mezôi lehetnek egyezô nevüek számuk 256; 6000 byte, a memóriaváltozók tartalma .MEM állományba menthetô típus jellemzôk : karakteres - max. 254 karakter hosszú, helyigény a karakterek száma + 2 numerikus - helyigény 9 byte dátum - helyfoglalás 9 byte logikai - 2 byte • automatikus deklarálás • értékadás STORE <kif.> TO <memvnév [lista]> vagy <memv.>=<kif> • értékvisszajelzés SET TALK ON, DISPLAY MEMORY • változó törlése RELEASE <memv.név [lista]> , RELEASE ALL LIKE <lista> RELEASE ALL EXCEPT lista arról amit nem akarunk

törölni CLEAR MEMORY az összes változó törlése • memóriavált. tartalmának mentése SAVE TO <áll.név> [ALL, LIKE, EXCEPT] • visszatöltés RESTORE FROM <állomány név> [ADDITIVE] csak az eddig még nem létezô változók jönnek be 3. A1 tétel Állapottér és típus fogalma Állapot: az az értékegyüttes, amelyet a megoldandó feladat minden lényeges adata, konkrét értékként, egy adott idôpillanatban felvesz. A feladat (algoritmus) megoldása során a programnak egy kezdô ál-lapotból, amit az úgynevezett elôfeltételben határozunk meg, egy végállapotba kell eljutnia. A vég-állapotot, mint elérendô célt nevezzük utófeltételnek. A program folyamatában, a kezdô állapottól a végállapotig bekövetkezô, lehetséges állapotok halma-zát állapottérnek nevezzük. Típus fogalma: Típusnak nevezünk egy adathalmazt és a rajta müveletek összességét amelyet a típus konstrukció ír le. Típuskonstrukció : típus

definiálása más típusokon keresztül. Tipusértékhalmaz : egy adat lehetséges értékeinek halmaza. értelmezett Elemi típus: bit típusérték halmaza {0,1} mûveletek halmaza {or, and, not, xor, <, >, =} Adattípusok a Turbo Pascalban: értékek 1.Egyszerû típusok - Egészek: Byte Word ShortInt Integer Longint - Logikai: Boolean - Karakter: Char - Felsorolt: 0.255 0.65,535 -128.127 -32,768.32,767 -2,147,483,648.2,147,483,647 - Intervallum: intervalluma True,False bármely ASCII karakter Pl: A a felsorolásban szereplô elemek Pl T=(ôsz,tél) a már létezô sorszámozott típus egy Pl: T = 1.100 - Valós: Real 2.9E-3917E38 Single 1.5E4534E38 Double 5.0E-32417E308 Extended 3.4E-493211E4932 Comp -2(63-on)+1.2(63-on)-1 (Lebegôpontos ábrázolás, Real "felett" aritmetikai társprocesszor szükséges, illetve annak emulálása. Lásd $N és $E direktivákat) 2.Struktúrált típusok - String: String[szám] Legfeljebb szám hosszúságú ASCII

karakter - Tömb: Tomb : Array[index1,index2.] of alaptípus (index csak sorszámozott típusú, az indexszámtól függ a dimenzió) - Record: Valami = Record [mezôlista;] [Case [szelektor:] sorszámozott típus of értékleírás : (mezôleírás) [;értékleírás : (mezôleírás).]] End; ( A késôbbiekben láthatunk rá példákat) - Halmaz: Sorszámozott típusú elemek, maximum 256 db. Set of alaptípus; Pl: Nagybetu = Set of (A.Z) - Állomány: Típusos --> File of alaptípus Pl : File of Integer; (Komponensei egyforma méretûek, az alaptípus nem lehet állomány ill. objektum típus) Típus nélküli --> File Tipikus --> Pl : BlockRead/Write Szöveges --> Text Felhasználásuk --> Pl : Listafile (Csak szekvenciális elérés, soros szervezés) - Eljárás Procedure(formális paraméterlista) Function(formális paraméterlista): típusazonosító (paraméterlista elhagyható) - (Objektum) 3.mutató típusok - Típusos: 4 byte-os memóriacímet tartalmaz Mut =

^alaptípus azonosítója - Típus nélküli: 4 byte-os memóriacímet tartalmaz Pointer (Mutatók felhasználása pl. Listaszerkezetnél) Típuskonstrukciók: 1.Direkt szorzat típus: Adott 2 halmaz, mindkettôben 1-1 típusnak megfelelô elemek vannak. Ha mindkét halmazból 1-1 elemet kiválasztunk és egymás mellé rendeljük ôket, egy harmadik összetett típusú halmazt kapunk. Ez a számpárokat tartalmazza, típusukkal együtt. Matematikai jelölése : A X B=(a,b) Programozásban pl. : a rekord szerkezet Típusok : A : B : Elegy = Record Szám: Név : End; Egészek String A B 2.Alternatív (unió) típus: Adott 2 halmaz amelybe 1-1 típusnak megfelelô elemek vannak, e két halmaz uniójából hozzuk létre az összetett típusú(alternatív) halmazt. Az alternatív szó, a választhatóságra utal, amely azt jelenti, hogy vagy az egyik típusú elemek közül választunk, vagy a másik típusúak közül, egy szelektortól függôen. Matematikában jelölve : A = B U

C Programozásban pl. : Variálható rekord Valtrek = Record Szerzo : String; --> A könyvekre vonatkozik az egész rekord, Cim : String; --> de a szelektortól függôen : Case Kulcs : Char of n : (Hely : Record Terem : Char; --> ha N, a könyvek Polc : Integer; --> helyének adatai Sorsz : Integer; --> szerepelnek. End); I : (Olvaso: Record Nev : String; --> ha I, a kölcsönzôk Cim : String; --> adatai szerepelnek. End); End; 3.Sorozat (iterált) típus : Adott egy alaptípus, különbözô véges sorozatokat képzünk ilyen típusú elemekbôl, és ez a sorozathalmaz lesz az iterált (sorozat) típus. Programozásban megvalósítva pl. : tömb Pascalban a) a string vektorként is felfogható (karaktertömb, karakterfüzér) b) tömb állhat string típusú elemekbôl, ekkor ez még összetettebb c) Tombi = Array [1.10,210] of Integer; 2 dimenziós, egész számokból álló mátrix. 3. A2 tétel Elemi programkonstrukciók a Turbo PASCAL-ban (értékadás,

input-output műveletek, elágazások, ciklusok, stb) Alapvető I/O műveletek: A Pascal programozásban a standard output (szabványos kimenet) periféria a képernyő. A képernyőre két eljárással írhatunk: Write(paraméterek); Writeln(paraméterek); A paramétereket vesszővel elválasztva kell felsorolni. A paraméterek lehetnek: - szöveg ‘’ aposztrófok között, - változónevek, - konstansok, - aritmetikai kifejezések, - logikai kifejezések, - függvényhívás. A Write és a Writeln eljárások között az alábbi különbség van: A Write eljárás a kurzor által mutatott pozícióra ír, és a kurzort a kiírás utáni pozícióban hagyja. A Writeln eljárás is a kurzor által mutatott pozíciótól ír, azonban a paramétereknek a képernyőre való kiírása után a következő sor elejére állítja a kurzort. A paraméter nélküli Writeln eljárással üres sort írhatunk a képernyőre. Egész típusú eredmények kiíratása: Write(paraméter : n), vagy

Writeln(paraméter : n), ahol n egész szám, a mező szélessége. Valós eredmények kiíratása: Write(paraméter : n : m), vagy Writeln(paraméter : n : m), ahol m egész szám, mezőszélesség, n egész szám, a tizedek száma. Boolean típusú eredmények kiíratása: Write(n), vagy Writeln(n), ahol n true vagy false. A Turbo PASCAL-ban a standard input (szabványos bemeneti) periféria a billentyűzet. A Read és a Readln eljárások felfüggesztik a program futását és a klaviatúráról az ENTER billentyű lenyomásáig olvassák az adatokat. Read(paraméterek); Readln(paraméterek); A paraméterek: Csak változók lehetnek, kivételt képeznek a boolean változók, mivel azok értékét nem lehet beolvasni billentyűzetről. A Read eljárás felfüggeszti a program futását, és várja az adatok billentyűzeten való begépelését befejezve az ENTER leütésével. A Read utasítás a begépelt adatokból sorra értéket ad a paramétereinek. A Readln eljárás egy sort

olvas be, egyetlen paraméterének ad értéket. Értékadó utasítások A legalapvetőbb Pascal utasítás az értékadás, amely áll egy bal oldalból és egy jobb oldalból, a két oldalt az értékadás jele, a := köti össze. A bal oldalon csak változó állhat, a jobb oldalon állhat konstans, változó és kifejezés. A konstans, a változó valamint a kiértékelt kifejezés egyetlen értéket képvisel, melyet a bal oldalon lévő változó vesz fel. Az értékadó utasítás formája: bal oldal:=jobb oldal; Aritmetikai értékadás: az aritmetikai értékadásnál a változó numerikus értéket vesz fel. szk:=((a+b)/2); Logikai értékadás: a Boolean típusú változók true vagy false értéket vehet fel. b1:=true; Rekordérték adó utasítás: A with utasítással egyszerűbben adhatunk rekordnak értéket, Általános formája: with rekord változó do utasítás; Elágazások Az if utasítás kétirányú, feltételes elágazást hajt végre . Az if utasítás

általános formája: if logikai kifejezés then utasítás1 else utasítás2; A case utasítással könnyen megoldható a program többirányú elágaztatása. Általános formája: case szelektor of cimke1 : utasítás1; . cimken : utasításn; else : utasítás m; end; Ciklusok A for ciklusutasítást akkor használjuk, ha pontosan ismerjük az ismétlések darabszámát, így a ciklusmagot egy meghatározott számszor végrehajtjuk. Általános alakja: for ciklusváltozó:=kezdőérték to végérték do begin utasítások; end; A while utasítás tartalmaz egy logikai kifejezést, amely vezérli az ismételt utasítások végrehajtását. A while utasítás formája: while logikai kifejezés do begin utasítások; end; A repeat until között megadott utasítások ismételten hajtódnak végre. Eb ben az esetben a logikai kifejezést kilépési feltételnek hívjuk. Az utasítás általános alakja: repeat ciklusmag; until logikai kifejezés; 4. A1 tétel Elemi

programozási struktúrák. A szekvencia, az elágazás, a ciklus mint elemi struktúrák felépítése Az algoritmus leíró eszközei a stuktogram. blokkdiagram, a szöveges leírás és a Szekvenciának nevezzük a sorban egymás után való utasít végrehajtását. Pl.: Elágazásnak nevezzük azt, ha egy algoritmus során elágazunk, továbbra is előre megyünk. ások de Ciklusnak nevezzük azt, amikor elágazunk, és az algoritmus egy előbbi sorára visszatérünk egy időre, amíg a megadott feltételt vagy feltételeket ki nem elégítjük. 4. A2 tétel Típusfogalom, típusdeklarációk a Turbo PASCAL-ban Típus fogalma: Típusnak nevezünk egy halmazt és a rajta értelmezett műveletek összességét amelyet a típus konstrukció ír le. Típuskonstrukció: típus definiálása más típusokon keresztül. Elemi típusértékhalmazok: - Egész számok halmaza Racionális számok halmaza Logikai értékek halmaza Karakterek halmaza 1. Egyszerű típusok -

Egészek: Byte Word ShortInt Integer Longint - Logikai: Boolean - Karakter: Char - Felsorolt: - Intervallum: intervalluma - Valós: Real Single Double Extended Comp értékek 0.255 0.65,535 -128.127 -32,768.32,767 -2,147,483,648.2,147,483,647 True, False bármely ASCII karakter Pl: A a felsorolásban szereplő elemek Pl: T=(öszérték) a már létező sorszámozott típus egy Pl: T = 1.100 2.9E-3917E38 1.5E4534E38 5.0E-32417E308 3.4E-493211E4932 -2(63-on)+1.2(63-on)-1 (Lebegőpontos ábrázolás, Real "felett" aritmetikai társprocesszor szükséges, illetve annak emulálása. Lásd $N és $E direktivákat.) 2. Struktúrált típusok - String: String[m] Legfeljebb m hosszúságú ASCII karakter - Tömb: Tomb : Array[index1, index2.] of alaptípus (index csak sorszámozott típusú, az indexszámtól függ a dimenzió) - Record: Valami = Record [mezőlista;] [Case [szelektor:] sorszámozott típus of értékleírás : (mezéleírás) [;értékleírás : (mezőleírás).]]

End; - Halmaz: Sorszámozott típusú elemek, maximum 256 db. Set of alaptípus; Pl: Nagybetu = Set of (A.Z) - Állomány: Típusos: File of alaptípus Pl : File of Integer; (Komponensei egyforma méretek, az alaptípus nem lehet állomány ill.objektum típus) Típus nélküli: File Tipikus --> Pl : BlockRead/Write Szöveges: Text Felhasználásuk --> Pl : Listafile (Csak szekvenciális elérés, soros szervezés) - Eljárás Procedure(formális paraméterlista) Function(formális paraméterlista): típusazonosító (paraméterlista elhagyható) - (Objektum) 3.mutató típusok - Típusos: 4 byte-os memóriacímet tartalmaz Mut = ^alaptípus azonosítója - Típus nélküli: 4 byte-os memóriacímet tartalmaz Pointer (Mutatók felhasználása pl. Listaszerkezetnél) Típuskonstrukciók 1.Direkt szorzat típus: Adott 2 halmaz, mindkettőben 1-1 típusnak megfelelő elemek vannak. Ha mindkét halmazból 1 -1 elemet kiválasztunk és egymás mellé rendeljük őket, egy harmadik

összetett típusú halmazt kapunk. Ez a számpárokat tartalmazza, típusukkal együtt. Matematikai jelölése : A X B=(a,b) Programozásban pl. : a rekord szerkezet 2.Alternatív (unió) típus: Adott 2 halmaz amelybe 1 -1 típusnak megfelelő elemek vannak, e két halmaz uniójából hozzuk létre az összetett típusú (alternatív) halmazt. Az alternatív szó, a választhatóságra utal, amely azt jelenti, hogy v agy az egyik típusú elemek közül választunk, vagy a másik típusúak közül, egy szelektortól függően. Matematik ban jelölve : A = B U C Programozásban pl. : Variálható rekord 3.Sorozat (iterált) típus : Adott egy alaptípus, különböző véges sorozatokat képzünk ilyen típusú elemekből, és ez a sorozathalmaz lesz az iterált (sorozat) típus. Programozásban megvalósítva pl.: tömb Pascal-ban a) a string vektorként is felfogható b) tömb állhat string típusú elemekből, ekkor ez még összetettebb c) Tombi = Array [1.10],[210] of Integer;

- 2 dimenziós, egész számokból álló mátrix. 4.B tétel Tömbkezelés a FoxPro 2.5 - ben A tömbök létrehozása a DIMENSION parancsal történik. Szintaxisa: DIMENSION <tömb1>(<kifN1>[,<kifN2>])[,<tömb2>(<kifN3>[,<kifN4>])]. <tömb1> - a létrehozandó tömb neve. Egyszerre több tömb is létrehozható (<tömb2>, <tömb3>. stb) <kifN1>[,<kifN2>] - a tömb dimenziójának és méretének meghatározása. Ha csak <kifN1>-et adjuk meg, akkor egydimenziós tömböt hozunk létre, egyébként kétdimenzióst. <kifN1> és <kifN2> a sorok, illetve oszlopok száma Tömböt definiálhatunk még a DECLARE paranccsal is .A parancs hatása és szintaxisa teljes mértékben megegyezik a DIMENSION parancséval. Szintaxisa: DECLARE <tömb1>(<kifN1>[,<kifN2>])[,<tömb2>(<kifN3>[,<kifN4>])]. A harmadik parancs tömbdefiniálásra a PUBLIC parancs. Szintaxisa : - tömb

esetén : PUBIC ARRAY <tömb1>(<kifN1>,<kifN2>)[,<tömb2>(<kifN3> [,<kifNl4>])). ARRAY <tömb1> (<kifN1>,<kifN2>)[,<tömb2> (<kifN3> [,<kitNl4>])). - egy vagy több public tömb neve. <kifN1> - az egydimenziós elemeinekszáma ; <kifN1>, kifN2> kétdimenziós tömb definiálása . A PUBLIC utasítás segítségével olyan változókat deklarálhatunk, amelyek érvényessége a program összes eljárására és felhasználói függvényére kiterjed. A Parancsablakban létrehozott minden változó autoatikusan GLOBÁL IS lesz. Tömbkezelés ACOPY(): Elemek másolása egyik tömbből egy másikba. ADEL(): Tömbelem törlése. ADIR(): Tömb feltöltése könyvtár-információkkal. AELEMENT(): Tömbelem sorszámának meghatározása a sor- és oszloppozíciója alapján. AFIELDS(): Tömb feltöltése az aktuális adatbázis szerkezetével. AINS(): Elem (sor vagy oszlop) beszúrása a tömb tetszőleges

helyére. ALEN(): Egy tömb elemeinek, sorainak vagy oszlopainak száma. ASCAN(): Tömbön belüli keresés. ASORT(): Tömbelemek rendezése. ASUBSCRIPT(): Sorszámmal megadott tömbelem melyik oszlopban illetve sorban található. A COPY TO ARRAY parancs segítségével adatbázisrekordból adatokat tudunk másolni tömbbe. A parancs szintaxisában meg kell adni a tömböt, amelybe a másolás történik. Megadhatjuk a mezőneveket is (a FIELDS kulcsszó után), amelyeket másolni szeretnénk. Az APPEND FROM ARRAY utasítással rekordokat tudunk atadni adatbázisnak egy tömbből. 5. A1 tétel Adatszerkezetek csoportosítása. Elemi adatszerkezetek fajtái, tulajdonságai. Az adattípusok megadása a típus értékkészletének, a rajta végzett műveleteknek, az értékel jelölésének és a tárban való ábrázolásának a rögzítését jelenti. Az adat típusaink kétfélék lehetnek: elemiek, amelyeknek felhasználói szempontból nincs belső szerkezetük, valamint

összetettek, amelyek elemiekből épülnek fel; ezek az adatszerkezetek. Elemi adattípusok Egész szám: Van olyan nyelv, amely megkülönbözteti az egész számokon végezhető műveleteket a valós számokon végezhetőktől. Az egész számokat legtöbbször 2 byte -on ábrázolják, kettes komplemens kódban. A számítógépes egész számok köre nem zárt az alapműveletekre, azaz lehetséges, hogy két egész szám összege nem számítható ki. Ezt nevezzük túlcsordulásnak. Valós számok: A számítógépen ábrázolható valós szá mok igazából nem valósak, hanem 2-es vagy 10 -es számrendszerben véges sok számjeggyel leírható racionális számok. A valós számokra kétféle korlátot ad hatunk: létezik egy nagyságrendi korlát és egy pontossági korlát. A valós számokra a műveletek sokasága létezik. Logikai érték: A Pascal ismeri a logikai típust, és rá vonatkozó műveleteket (AND, OR, NOT). Karakter: Egy ilyen változóban egy tetszőleges

karaktert tárolhatunk. A karakterek kódolására legt öbbször az ASCII kódrendszert használják. A karakterekre az összehasonlítás, a kódmegadás, a következő, illetve az előző karakter képzése műveleteket szokták megvalósítani. 5. A2 tétel Unit fogalma és alkalmazása. Saját unit létrehozása Unit fogalma: A modul önállóan lefordítható programegység, amely jól definiált kapcsolódási területen ( interface) keresztül kapcsolódik a program más részeihez. A modulok belső része rejtett a külvilág számára ( implementation). A Turbo Pascal modulokat unitoknak nevezzük. A külső unitokra való hivatkozást mindig a deklarációs rész elején kell elhelyezni. A uses kulcsszó után adjuk meg ezeket a szabványos, illetve saját modulok neveit. A modulok alkalmazása nélkül csak 64 Kbyte méretű programot tudunk létrehozni. Ha viszont unitokat használunk, akkor csak a memória mérete, illetve az operációs rendszer korlátozza a

lefordított program méretét, amely maximálisan 640 Kbyte lehet. A unitok felépítése: unit modulnév; { a modul fejléce, nem hagyható el } interface { a kapcsolódási felület rész } uses const type var eljárások és függvények fejlécei impementation { az implementációs rész } uses label const type var eljárások és függvények teljes deklarációja [[ begin { az inicializációs rész } Pascal utasítások ]] end. A unit -ok három jól elkülöníthető részből állnak, amelyek közül az inicializációs rész elhagyható. 1. Unitfej: Ezzel indul a unit A UNIT szó után megadjuk a unit nevét, amely egy tetszőleges azonosító, de meg kell egyeznie a file nevével. 2. Interface rész: Az INTERFACE szó vezeti be ezt a részt, és az itt deklarált típusok, konstansok, változók, eljárások, függvények a unitban, és a unitot meghívó programban egyaránt használhatóak. a.) Uses kulcsszó funkciója: definiáljuk, hogy a saját unitunk mely

unitokat fogja használni. A használni kívánt unitokat a USES szó után, vesszővel elválasztva, egyszerűen felsoroljuk. Szintaxisa : USES unitn‚v1[, unitn‚v2,., unitn‚vn]; Hatására a rendszer beszerkeszti a megadott unitokat. 3. Implementációs rész: Ezt a részt az IMPLEMENTATION szó vezeti be. Ebben a részben az interface -ben megnevezett függvényeket és eljárásokat definiálnunk kell. Most az eljárás és függvényfej után nem kell /de lehet/ írunk paraméterlistát. Ezt követi az alprogram törzse, a forrásprogramokkal teljesen azonos módon. Ebben a részben is állhatnak deklarációk; ezek lokálisak azaz csak a unitban használhatóak, szemben az interface részben ll globális - azaz minden, a unitot hívó prg.-ban ‚s unitban egyaránt alkalmazható - deklarációval. Használhatunk típusokat, változókat, konstansokat, cimkéket, eljárásokat, függvényeket ‚s unitokat. 4. Inicializációs rész : Ez a rész az implementáció után

helyezkedik el, a BEGIN és az END kulcsszavak között. Ha ez a rész üres a BEGIN elmaradhat. Ebben a részben kezdőértéket adhatunk a deklarált változóknak, megnyithatjuk az ott definiált file-okat, stb. Az inicializációs részben tulajdonképpen bármely, szabályos Tp utasítást leírhatunk. Ha egy programban unitot használunk, akkor a prg. futásakor először a deklarált unit inicializációs része hajtódik végre. 5. Fordítás és tárolás: Az EXE programban csak a meghívott eljárások/függvények/stb. fognak megjelenni A modulok fejléce - a modulok közötti kapcsolat A modulok fejléce a unit foglalt szóból és az azt követő modulnévből áll - sosem hagyható el. A modulnévnek meg kell egyeznie a modult tartalmazó file nevével. Például a unit Global; modult a GLOBAL.PAS file-ban kell elhelyezni A modul nevét használhatjuk más modulokkal illetve a főprogrammal való kapcsolat kialakítására: uses modulok listája; ahol a uses foglalt szót

a felhasználni kívánt modulok neveinek vesszővel tagolt listája követi. Például: uses CRT, Graph, Global; Az interface rész A kapcsolódási felület részt az interface foglalt szó nyitja meg. Ebben a részben található a unit globális objektumainak deklarációja, amelyek más modulokból is elérhetőek. A globális eljárásoknak és függvényeknek csak a fejléce adható meg az interface részen Saját unit készítése Vannak előre elkészített unitok is, de írhatunk saját unitokat is, az alábbi szintaktikai követelményekkel: UNIT n‚v; {unitfej} INTERFACE {globális deklarációk} USES unit1,.,unitn; {unitok} TYPE . ; {típusok deklarálása} CONST . ; {konstansok} LABEL . ; {címkék} VAR . ; {változók} PROCEDURE . ; {eljárásfejek} FUNCTION . ; {függvényfejek} IMPLEMENTATION {privát deklarációk} USES unit1,.,unitn; {unitok} TYPE . ; {típusok deklarálása} CONST . ; {konstansok} LABEL . ; {címkék} VAR . ; {változók} PROCEDURE . ;

{eljárásfejek} FUNCTION . ; {függvényfejek} BEGIN END. { inicializációs rész } 5. B tétel Matematikai függvények a Turbo PASCAL-ban és a FoxPro 2.5-ben, saját függvény készítése A TP matematikai függvényei Abs: visszatér az argumentum abszolút értékével. Szintaxis: Abs(x): azonos x típusával; x egész vagy valós típusú kifejezés. ArcTan: az x valós típusú kifejezés arkusztangens főértékét adja vissza radiánban. Szintaxis: ArcTan(x : real) : real; x : valós típusú kifejezés. Cos: visszatér az argumentum koszinusz értékével, x értékét radiánban kell megadni. Szintaxis: Cos(x : real) : real; x : valós típusú kifejezés. Exp: visszatér az argumentum exponenciális értékével. Szintaxis: Exp(x : real) : real; x : valós típusú kifejezés. Frac: Az x valós típusú kifejezés tizedes részét adj vissza. Szintaxis: Frac(x : real) : real; x : valós típusú kifejezés. Int: x valós típusú kifejezés egészrészét adja

vissza. Szintaxis: Int(x : real) : real; x : valós típusú kifejezés. Ln: visszatér az argumentum természetes alapú logaritmusával. Szintaxis: Ln(x : real) : real; x : valós típusú kifejezés. Odd: vizsgálja az argumentum páratlanságát, igaz értéket ad, ha az x páratlan, és hamisat, ha páros. Szintaxis: Odd(x : longint) : boolean; x : egész típusú kifejezés. Pi: Pi értékét adja vissza. Szintaxis: Pi : real; Random: visszatér egy véletlen számmal. Szintaxis: Random### (range : word) ###: range - től függ; ha range nincs megadva, akkor valós típusú 0 ### x ### 1, egyébként word típusú 0 ### x ### range véletlenszámot generál. Round: Valós típusú kifejezést a legközelebbi egészre kerekít. Szintaxis: Round(x : real) : longint; Sin: visszatér az argumentum szinusz értékével, x értékét radiánban kell megadni. Szintaxis: Sin(x : real) : real; x valós típusú kifejezés. Sqr: visszatér az argumentum négyzetével. Szintaxis: Sqr(x ) :

azonos x típusával; x valós vagy egész típusú kifejezés. Sqrt: visszatér az argumentum négyzetgyökével. Szintaxis: Sqrt(x: real) : real; x valós típusú kifejezés. Trunc: az x valós kifejezés 0 felé kerekített egészrészét adja vissza. Szintaxis: Trunc(x : real) : longint; x valós típusú kifejezés. A FoxPro 2.5 matematikai függvényei %: maradék (modulo) meghatározása, a Mod( ) függvénnyel azonos eredményt ad. Szintaxis: ###kifN1### % ###kifN2### kifN1### - az osztó, ###kifN2### - az osztandó Abs( ): Numerikus kifejezés abszolút értékének meghatározása. Visszaadott értéke 0 vagy pozitív szám. Szintaxis: Abs( ###kifN### ) kifN### - az a numerikus kif., melynek értékét kívánjuk meghatározni. Acos( ): Arcus cosinus érték meghatározása . Visszaadott értéke 0 és pi közé esik, a tizedesjegyek számát az érvényben lévő Set Decimals határozza meg. Szintaxis: Acos( ###kifN### ) ###kifN### - numerikus kif., amelynek arcus

cosinus értékét (radiánban) keressük, értéke -1 és +1 közé eshet. Asin( ): Arcus sinus érték meghatározása. Visszaadott értéke -pi/2 és +pi/2 közé esik, a tizedesjegyek számát az érvényben lévő Set Decimals határozza meg. Szintaxis: Asin( ###kifN### ) ###kifN### - numerikus kif. , amelynek arcus sinus értékét (radiánban) keressük, értéke -1 és +1 közé eshet. Atan( ): Arcus tangens érték meghatározása. Visszaadott értéke -pi/2 és +pi/2 közé esik, a tizedesjegyek számát az érvényben lévő Set Decimals határozza meg. Szintaxis: Atan( ###kifN### ) kifN### - az a tetszőleges numerikus kif., amelynek arcus tangens értékét (radiánban) keressük. Atan2( ): megadott koordinátapont által meghatározott szög radián értéke. Szintaxis: Atn2( ###kifN1###,###kifN2### ) ###kifN1###,###kifN2### - az x és y koordináták értéke. A ### kifN1###/###kifN2### hányadosnak -pi és +pi értéke közé kell esnie. Between( ): vizsgálja, hogy egy

kifejezés értéke a megadott másik két kifejezés értéke közé esik-e. A keresés karakteres, numerikus és dátum típusú is lehet. Visszaadott értéke igaz (True), ha a ###kifx1 ### értéke ###kifx2### és ###kifx3### közé esik különben hamis. Szintaxis: Between( ###kifx1###,###kifx2###,###kifx3### ) Ceiling( ): Numerikus érték felkerekítése a legközelebbi egész számra. Visszaadott értéke a ###kifN###-nél nagyobb vagy azzal egyenlő legközelebbi egész szám. Pozitív számnál a következő egész szám, negatív számnál az egészrész értéke. Szintaxis: Ceiling( ###kifN### ) ###kifN### a felkerekítendő szám, numerikus kif., memóriaváltozó, tömbelem is lehet. Cos( ): Cosinus érték meghatározása, visszaadott értéke -1 és +1 közé eső numerikus érték. A tizedesjegyek számát az érvényben lévő Set Decimals határozza meg. Szintaxis: Cos( ###kifN### ) ###kifN### - Tetszőleges numerikus érték radiánban. Dtor( ): szögérték

radiánba konvertálása Szintaxis: Dtor( ###kifN### ) ###kifN### - numerikus kif., a radiánba konvertálandó szögérték Fok:Perc:Másodperc alakban adható meg. Empty( ): Vizsgálja, hogy üres-e a kifejezés (###kifx###) Szintaxis: Empty( ###kifx###) ###kifx### - tetszőleges típusú kifejezés. Exp( ): exponenciális függvény értékének kiszámítása. A visszaadott érték numerikus, amely e-nek (mint a természetes alapú logaritmus alapszámának) a ###kifN### - re emelt hatványával egyenlő. Szintaxis: Exp( ###kifN### ) ###kifN### - az ex kifejezésből x értéke. Floor( ): a legközelebbi kisebb vagy egyenlő egész szám meghatározása, melynek visszaadott értéke a ###kifN### - hez legközelebb eső, annál kisebb vagy azzal egyenlő egész szám. Pozitív ###kifN### esetén az egészrész, negatív esetén a számnál kisebb egész. Szintaxis: Floor( ###kifN### ) ###kifN### - tetszőleges numerikus kifejezés. Int( ): a szám egész részének

meghatározása. Visszaadott értéke a ### kifN### egész része, amelyet a törtrész levágásával kapunk. Szintaxis: Int( ###kifN### ) ###kifN### - az a numerikus kif., amelynek az egészrészét keressük. Log( ): természetes logaritmus kiszámítása. Szintaxis: Log( ###kifN### ) ###kifN### - nullánál nagyobb szám! Log10( ): numerikus érték 10-es alapú logaritmusa. Szintaxis: Log10( ###kifN### ) ###kifN### - nullánál nagyobb numerikus érték. Max( ): tetszőleges (de azonos ) típusú kifejezések közül a legnagyobbat határozza meg és a kifejezések közül a legnagyobb értéket adja vissza. Szintaxis: Max( ###kifx1###,###kifx2######,###kifx3###.### ) ###kifx1###,###kifx2### . - a tetszőleges (azonos típusú), összehasonlítandó kifejezések. Min( ): tetszőleges (de azonos) típusú kifejezések közül a legkisebbet határozza meg és a kifejezések közül a legkisebb értéket adja vissza. Szintaxis: Max( ###kifx1###,###kifx2######,###kifx3###.### )

###kifx1###,###kifx2###. - a tetszőleges (azonos típusú), összehasonlítandó kifejezések. Mod( ): két szám osztási maradékának kiszámítása Szintaxis: Mod( ###kifN1###,###kifN2###) ###kifN1### - az osztó, ###kifN2### - az osztandó Pi( ): pi értékének visszaadása a Set Decimals által meghatározott tizedesjegy pontosságig. Szintaxis: Pi( ) Rand( ): 0 és 1 közötti véletlenszámot állít elő. Szintaxis: Rand( ###kifN### ) kifN### a véletlenszámot inicializáló érték. Ha nem adjuk meg, az alapértelmezés 100001 Ha negatív számot adunk meg, az inicializáló érték a rendszeróra alapján generálódik. A maximális véle tlenszerűség elérésére a Rand( ) függvényt először negatív argumentummal adjuk meg, majd argumentum nélkül. Round( ): kerekít a megadott tizedes jegyig és visszatér a kerekített numerikus értékkel. Szintaxis: Round( ###kifN1###,###kifN2###) kifN1### - a kerekítendő numerikus érték, ###kifN2### - a kerekítés hány

tizedesig történjen. Rtod( ): a radián értékét átváltja szögre. Szintaxis: Rtod( ###kifN###) ###kifN### - a szögre átváltandó radiánérték. Set Decimals( ): a tizedesjegyek számát határozza meg, csak a tizedesjegyek megjelenítésére van hatással, a számítás pontosságára nem hat ki. Szintaxis: Set Decimals To ######kifN###### ###kifN### - a maximálisan megjeleníthető tizedesjegyek száma (max. 18, min 0, alapértelmezés 2 ) Sign( ): az előjelfüggvény (sign) értékét adja vissza. A visszaadott érték 1, ha ###kifN### pozitív; 0, ha ###kifN### 0; -1, ha ###kifN### negatív. Szintaxis: Sign(###kifN###) ###kifN### - tetszőleges numerikus kifejezés. Sin ( ): szinuszérték meghatározása. Visszaadott értéke -1 és +1 közé eső szám, a ###kifN### sinusa. Szintaxis: Sin( ###kifN### ) ###kifN### - tetszőleges numerikus érték, melynek a sinusát akarjuk meghatározni. Sqrt( ): négyzetgyökvonásra szolgáló függvény, amely a ###kifN###

gyökét adja vissza. Szintaxis: Sqrt( ###kifN### ) ###kifN### - pozitív (vagy 0) numerikus érték, amelynek a gyökét keressük. Tan( ): tangens érték kiszámítása. Szintaxis: Tan( ###kifN### ) ###kifN### - radiánban megadott érték, amelynek a tangensét keressük. Saját függvény készítése TP-ben A függvény egy olyan alprogram, amely hívásakor a nevével ad vissza értéket a hívó programnak. Általános leírása: function függvény neve( paraméterlista ): függvény típusa ; lokális deklarációs rész ###label, const, type, var, procedure, function### begin a függvény törzse ( végrehajtható utasítások ) függvény neve := .; end; A függvény fejléce a function kulcsszóval következik a függvény azonosítója (a neve), a paraméterlistája és a függvény típusa. kezdődik, ezután formális A függvény azonosítójá t a Pascal azonosítóképzés szabályai szerint kell kialakítani. A függvény nevére vonatkozik a függvény

típusának a megadása, hiszen a típusnak megfelelő eredmény kerül bele. A függvény paraméterlistája tartalmazza azokat a változókat, amelyeket át kell vennie a hívó programtól. A paramétereknek nemcsak nevet kell adni, hanem a típusát is meg kell határozni. A függvénynél a paramétereket általában név szerint adjuk át, hiszen ebben adjuk meg az értékeket, amivel a függvény számol. Bonyolultabb esetben a cím szerinti paraméterátadás is használható, pl. hibajelzés céljából A függvény típusát is a függvény fejlécében kell megadni . Ez magától értetődő hiszen a függvény általában egyetlen értéket állít elő és ezt a függvény nevével adja vissza, a definiált típusnak megfelelően . A függvény szükséges lokális deklarációi a függvény fejléce alatt találhatók. Ezeket csak a függvény használja A függvény törzse tartalmazza azokat a műveleteket, amelyeket a függvénynek végre kell hajtani ahhoz, hogy

megadja a visszatérési értéket a hívó programnak. Ezeket az utasításokat begin és end közé kell tenni és pontosvesszővel lezárni. Az alábbi két dolgot nem tehetjük meg: 1. A függvény neve a függvény törzsén belül nem szerepelhet az értékadás jobb oldalán. Kivéve azt az esetet, ha szándékosan rekurzívan kívánjuk hívni. 2. A függvény azonosító neve nem szerepelhet az értékadó utasítás bal oldalán a függvény törzsén kívül. 6. A1 tétel Összetett adatszerkezetek felsorolása, csoportosítási lehetőségei Az összetett adatszerkezetek, elemi adattípusok halmaza, valamilyen megadott összefüggés szerint. Három féle összetételi módja lehet: a., azonos típusokból összetett adatszerkezet b., különböző típusokból összetett adatszerkezet c., alternatív szerkezet A következő műveletek végezhetők az összetett adaszerkezetekkel: - tetszőleges sorszámú elem értékének felhasználása vagy megváltoz-tatása a

sorozat első eleme értékének felhasználása vagy megváltoztatása a sorozat utolsó eleme értékének felhasználása vagy megváltoztatása - a sorozat következő eleme értékének felhasználása vagy megváltoz-tatása - a sorozat elemszámának meghatározása - új elem felvétele a sorozat elejére - új elem felvétele a sorozat végére - új elem felvétele a sorozat két adott eleme közé - a sorozat első elemének kivétele a sorozatból - a sorozat utolsó elemének kivétele a sorozatból - a sorozat adott elemének kivétele a sorozatból - a sorozat ürességének vizsgálása - a sorozat ürességének vizsgálata - a sorozat részhalmazának felhasználása vagy megváltoztatása Az adatszerkezetek szorosan összefüggnek a velük végezhető műveletekkel. Azt, hogy egy adathalmaz hogyan helyezkedik el a tárolóeszközön fizikailag, fizikai adatsornak hívjuk. Tömb: Táblázat vagy mátrix lehet. Dimenzió: kiterjedés a síkban Az egyes tömbbeli elemek

változó adattípusokat tartalmaznak. Az egydimenziós tömböket más néven vektornak nevezzük. A tömb statikus határai fixek. 11 12 13 21 22 23 31 32 33 sorfolytonos 11 21 31 12 22 32 13 23 33 oszlopfolytonos A táblázat sor - és oszlopfolytonos elhelyezés között a kapcsolat címfüggvényen keresztül valósul meg. A cím sorfolytonos ábrázolása: CS(i,j)=a11+(i-1)n+(j-1) A cím oszlopfolytonos ábrázolása: CO(i,j)=a11+(j-1)m+(i-1) Szöveg: Ha egy adott tömb csak karaktereket tartalmaz és a tömbhatárok dinamikusak, akkor, akkor szöveges összetett adatszerkezetről beszélünk. Ez szükséges a szövegszerkesztésnél Verem: A verem olyan sorozat, amelynek csak az egyik végét tudjuk kezelni, oda tehetünk be új elemet és onnan vehetünk ki elemet. Amit legutoljára tettünk be, azt kell kivenni először. Ez angolul Last In First Out (LIFO). A vele végezhető műveletek: a verem tetejére való ráhelyezés és a verem tetejéről való levétel.

d c b a PUSH(x): tegyünk be adott elemet POP(x): kiveszünk egy elemet úgy hogy fizikailag is kikerüljön. Műveletek: Eljárás (Üresre állítás) VM:=1 Eljárás vége. Eljárás (PUSH(x)) Ha VM>N akkor HIBA („betelt a verem”) különben V(VM):=x : VM:=VM+1 Ha vége Eljárás vége. Eljárás (POP(x)) Ha VM:=1 akkor HIBA („üres a verem”) különben VM:=VM-1 : x:=V(VM) Ha vége Eljárás vége. Sor: A sor olyan sorozat, amelynek az egyik végére lehet tenni új elemeket, a másik végéről pedig el lehet venni őket. Amit először tettem be, azt veszem ki először. Angolul First In First Out (FIFO). u 5 4 3 2 1 S(N): n elemet tartalmazó sor Műveletek: Eljárás (Üresre állítás) HOVA:=1 : HONNAN:=1 Eljárás vége. Eljárás (SORBA(x)) Ha HOVA>N akkor HIBA(„betelt a sor”) különben S(HOVA):=x : HOVA:=HOVA+1 Ha vége Eljárás vége. Eljárás(SORBÓL(x)) Ha HONNAN:=HOVA akkor HIBA(„üres a sor”) különben x:=S(HONNAN) : HONNAN:=HONNAN-1 Ha

vége Eljárás vége. Lista: A lista adatok egymás után láncolása valamilyen sorrendben. listafej 0 1 speciális mutató Adat 2 Adat 3 Adat A mutatókat külön vektorban helyezzük el. gyűrűnek nevezzük, amikor a lista listafejhez. 4 Cikluslistának vagy végét visszaláncoljuk a Record: A recordok valamilyen szempontból összefüggő adatok ,közös területen való egymásután írása. Szelekciós o perátor, valamilyen pont. A recordok halmazát file -oknak nevezzük. Nagy tömegű adatok tárolásánál használjuk. Műveletek: beírás, kiolvasás, törlés, record elemének módosítása, szelekció vagy kiválasztás. Név Név Név Fizetés Fizetés Fizetés Alternatív szerkezet: Olyan, mint a record, csak a record mezői típusától eltérnek egymástól. A háttértárolón való tárolás szempontjából szekvenciális-, direkt - és indexelt állományokat különböztetünk meg. Szekvenciális állomány: Kétféle szekvenciális file-t

különböztetünk meg. Szekvenciális Input file és Szekvenciális Output file. Ez voltaképpen a sorhoz hasonlít. Az input file-ból csak olvashatunk, az output file-ba pedig csak írhatunk. Műveletek: - bemeneti állományvégének érzékelése - a kimeneti állomány végére írás - az első elem feldolgozása és a következőre való lépés. Direkt állomány: Olvasható és írható egyszerre. A direktállományokban minden e gyes recordhoz hozzá van rendelve egy sorszám. Műveletek: - adott sorszámú record felhasználása ill. módosítása - új record felvétele Indexelt állomány: Az indexelt állományoknál létezik egy úgynevezett indexelt tábla, ahol az indexek rendezve vannak, és jelö lve van, hogy az indexek mely adatokra mutatnak. Ha az indextábla elemeit sorba, egymás után vagy szekvenciálisan érjük el, akkor az állományt indexelt állománynak nevezzük. Műveletek: - első record beolvasása, kiíratása - logikailag következő record

beolvasása, kiírása - adott kulcsú record beolvasása, kiírása - adott sorszámú record beolvasása, kiírása Gráf: Pontokból és vonalakból álló ábra. Rendezett számpárokkal jelöljük. G(v,e), ahol v:vertex (csúcs), az e:edge ( él). A gráfot szomszédsági-, él- vagy csúcsmátrixszal ábrázoljuk. Fa: A fa olyan összetett gráf, amely egyszerű, körmentes, összefüggő gráf. Az adatokat a fa bejárásával érhetjük el Háromféle bejárási stratégia létezik: 1., KBJ (Középső, Baloldali, Jobboldali) 2., BKJ (Baloldali, Középső, Jobboldali) 3., BJK (Baloldali, Jobboldali, Középső) Gyökérelemnek nevezzük azt az elemet, amelybe be nem vezet út, csak ki. Halmaz: A halmaz egy olyan adatszerkezet, amelynek nincs meghatár sorrendje. Műveletei az ismert halmazműveletek ozva a 6. A2 tétel Sorolja fel a file-típusokat Turbo PASCAL-ban. Ismertesse a típus nélküli file-ok alkalmazásának sajátosságait Turbo PASCAL-ban. A Turbo PASCAL

-ban ismerünk szöveges file-okat, típusos állományokat és típus nélküli állományokat. Típus nélküli állomány: FILE A típus nélküli file-ok használata a Turbo PASCAL-ban nagy segítséget jelent ismeretlen szerkezetű file-ok feldolgozásában. A típus nélküli file -ból tetszőleges adatok olvashatók illetve írhatók a file-ba. Mivel az adatforgalom a file és a program között mindenféle ellenőrzés nélkül megy végbe, gyors file-kezelés valósítható meg. A típus nélküli file -okkal végzett műveletekben egyetlen lépésben elérhető egység a blokk. A blokk mérete alapértelmezés szerint 128 byte, de ez a file nyitásakor a reset és a rewrit e eljárások második paraméterével módosíthatók. A típus nélküli file-ok írása és olvasása szintén blokkokban történik. Művelet Deklaráció Irás/olvasás jellege Összerendelés Nyitási módok Írás Olvasás Pozicionálás Pozíció- és fileméret Típus nélküli Var f:file; egy

komponens 128 byte-os blokkban írható vagy olvasható Assign(f,filenév) Reset(f,rekordmeret): írás, olvasás Rewrite(f,rekordmeret): írás, olvasás újralétrehozás BlockWrite(f,komp) BlockRead(f,komp) Seek(f,n) Filepos(f): longint; Sizeof(f,komponens); Filesize(f); 6. B Hierarchikus, relációs és hálós adatbázisok definíciója, tulajdonságai Hierarchikus adatbázisok Ezek voltak az első adatbáziskezelő rendszerek. Jellemző rá az alá és fölérendeltségi viszony. Ezek az adatbázisok nagy fejlettségi szintűek. Legismertebb a fastruktúra. Az adatbáziskezelő rendszereknek két dologgal kell foglalkozniuk: menteni és olvasni. Rekonstrukció: visszaállítás. Nincsen mutató a táblázatban A gráfban létezik mutató, de a rekonstrukció bonyolult. Olyan rendszerekben, amikor az alá és fölérendelések egyértelműek, a hierarchikus modell gépileg jól és hatékonyan megvalósítható módon írja le a valóságot. Napjainkra ugyan elavultnak

tekintett modell hatékonyabban működik a relációs panel miatt, ha a feldolgozás sorrendje megegyezik a hierarchiával. Lévén, hogy kötött hierarchiájú adatbázis, rendkívül körültekintően kell eljárni a felépítésekor. A lekérdezések az ilyen adatbázisban a hierarchia megkerülésével nem végezhetők el, ezért ez igen lassú. Pl.: Fa struktúra IGAZGATÓ ↓ 1:n FŐOSZTÁLYVEZETŐ ↓ 1:n OSZTÁLYVEZETŐK ↓ 1:n DOLGOZÓK Ez a séma elmondja, hogy ki milyen szinten helyezkedhet el. IGAZGATÓ FŐOSZTÁLYVEZETŐ1 OSZTÁLYVEZETŐ1-1 FŐOSZTÁLYVEZETŐ2 OSZTÁLYVEZETŐ1-2 2 OSZTÁLYVEZETŐ2-1 A1 E1 E2 E3 FŐOSZTÁLYVEZETŐ3 NIL OSZTÁLYVEZETŐ2- Az ilyen adatbázisoknál is beszélhetünk indexelt adatbázisokról. 2 mutatóval visszafelé is bejárható. A mutatók segítségével az egyes rekordokat hierarchia szerint rendezhetjük. Amennyiben minden egyes rekordhoz 1 mutatót rendelünk, az így felállított faszerkezetet csak egy irányban

tudjuk bejárni. Több mutató esetén a fát átjárhatóvá tehetjük f entről lefelé vagy lentről felfelé is. Problémát jelent az 1:N kapcsolat megvalósítása is. Az 1:N -es struktúra megvalósításához legalább kettő pointer szükséges. Az adatmodellen végezhető műveleteken további pointerek is szükségesek lehetnek. A sok pointer kezelése egy jó hiba forrás. Jellemzője: 1 szülőrekordnak több gyerekrekordja lehet, míg 1 gyerekrekordnak csak 1 szülőrekordja lehet. Hálós modell A hálós szerkezet az adatstruktúrában olyan általánosított hierarchikus kapcsolatot jelent, ahol az elemek között nemcsak 1:N, hanem bármilyen, így N:M (több-több) kapcsolat is fennállhat, s nem kell benne lennie kitüntetett gyökérnek, sem leveleknek. Más szavakkal: egy elemnek több közvetlen szülője is lehetséges. A hierarchikus és hálós adatmodellhez szabványosított utasítások léteznek. Az egyes rekordok tartalmát sémaleíró határozza meg.

A sémaleírás kapcsolatot létesít a felhasználói program és a séma között. Adatkezelő nyelv, mely ezekhez a modellekhez illeszkedő tipikus műveletek gyűjteménye. A nyelvek, amelyek támogatják az ilyen rendszereket pl.: a COBOL, PL 1, ASSEMBLY. Az adatkezelő nyelvben hasonló utasítások vannak. Hálós adatbázis: M TELEPHELY 1 VEVŐ M 1 1 ELADÓ M MEGRENDELÉS M N ÁRU 1 1 SPECIFIKÁCIÓ M N SZÁLLITÓ M N RAKTÁR Az NM-es kapcsolatokat kapcsoló rekordok segítségével valósítják meg. A kapcsoló rekordok az egyes rekordok közötti pointer kapcsolatát valósítják meg. A kapcsoló rekordok lévén az egyes rekordtípusok, sémák nem kell, hogy tartalmazzanak közvetlen mutatókat a másik rekordsémákra, elegendő csak a kapcsolórekordokra mutatni. Ahhoz, hogy a felhasználó dolgozni tudjon az adatbázissal, szükséges, hogy megfelelő módon, az adatok felvitelekor, fizikailag helyezze el az adatbázisban. Szempontok: A felhasználás

logikai sorrendjének megfelelő adatok definiálva legyenek. A felhasználó ismerje azokat a lehetőségeket, amelyek alapján mozoghat az adatbázisban. A hálós illetve hierarchikus adatmod ellek egyes célfeladatok megoldásánál jelent előnyt a relációs adatmodellel szemben, ellenben kezelése, karbantartása, továbbfejlesztése strukturális kötöttségek miatt nehézkes. Újabb bővítések, működésbeli módosítások véghezvitele nehézkesebb és költségese bb, mint a relációs adatmodell. 7. A1 tétel Elemi programozási tételek I.: összegzés, eldöntés, kiválasztás Összegzés tétele Általános feladat: Adott egy N elemű számsorozat. Számoljuk ki az elemek összegét! A sorozatot most és a továbbiakban is az N elemű A(N) vektorban tároljuk. Algoritmus: Eljárás S:=0 Ciklus I=1-től N-ig S:=S+A(I) Ciklus vége Eljárás vége. Eldöntés tétele Általános feladat: Adott egy N elemű sorozat és egy, a sorozat elemein értelmezett T

tulajdonság. Az algoritmus eredménye: annak eldöntése, hogy van -e a sorozatban legalább egy T tulajdonsággal rendelkező elem. 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 Eljárás vége Kiválasztás tétele Általános feladat: Adott egy N elemű sorozat, egy, a sorozat elemein értelmezett T tulajdonság, valamint azt is 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. 7. A2 tétel Tömb és rekordtípus a Turbo PASCAL-ban TÖMB TÍPUS: ARRAY [Indextipus[,Indextipus.]] of alaptipus Egy tömbnek fix számú eleme van, és az összes elemnek ugyanaz a típusa. Az elemek típusát alaptípusnak nevezzük. Az elemek indexelhetôk, mégpedig bármely sorszámozott típus egymás utáni értékével. Az index típusát indextípusnak

nevezzük. Pl: az Array [BYTE] of Char tömb karakterekbôl áll, és indexének típusa Byte. Eszerint e tömbnek van egy nulladik, egy elsô stb. eleme, az utolsó a 255elem Így a tömbnek összesen 256 eleme van. Az elemek számát az indextípus számossága határozza meg. Az indextípus gyakran egy intervallum típus. Az Array [1020] of Integer tömbnek 11 db. Integer típusú eleme van, azaz indexei 10,11,,20 Az Array [A.Z] of Boolean tömb 26 db logikai kapcsolóból áll, hiszen az angol ABC -nek 26 betűje van. A tömb elemei maguk is lehetnek tömbök, mely elemei szintén lehetnek tömbök. Így deklarálhatunk két, három ill. akárhány dimenziójú tömböt. Gyakran az egydimenziós tömböt vektornak, a kétdimenzióst mátrixnak szoktuk nevezni. A következô két deklaráció ugyanolyan két dimenziós tömböt ad meg: Var Tomb1:Array [1.10] of Array [031] of Real; Tomb2:Array [1.10,031] of Real; Az összes elemszámot az indextipu sok számosságának a szorzata

adja meg. Tomb1 és Tomb2 összesen 10*32= 320 Real tipusú számot tartalmaz. Két dimenzió esetén az elsô index a sorokat szokta indexelni, míg a második az oszlopokat. E tömböknek tehát 10 soruk és 32 oszlopuk van TÖMB TIPUSÚ KONSTANS (Konstans kifejezés[,konstans kifejezés]) Tömb tipusú konstanst csak a CONST deklarációs részben adhatunk meg a típusos konstans kezdôértékeként. Az elemeket zárójelben, vesszôkkel elválasztva kell megadni. Karaktertömb esetén konstansként az elemek számával megegyezô hosszúságú karakterlánc is megadható. Hivatkozás a tömb egy elemére: Tömbazonosító [Index] [[Index].] Tömbazonosító [Index[,Index.]] Pl.: T1 [3]=a, T2[1,3]=1,3, T2 [1][1]:=1,1, T3[True,2,3]=19 Tárolás: a tárolás sorfolytonosan történik, elôbb a belsô index növekszik. A foglalt memóriaterület méretét az alaptipus mérete és az egyes indextipusok számossága határozza meg. Az elôbbi T1 tömb például 4*1= 4 Byte-ot, T2 2*36=

36 Byte-ot, T3 pedig 2342= 48 Byte -ot foglal el a memóriából. A $A direktíva (Word Assign Data) a tömb elemeire nincs hatással. Speciális tömbök: Direkt memória-elérést szolgáló elôre deklarált tömbök: MEM [Szegmens : eltolás]---hivatkozás egy Byte tipusú elemre MEMW[Szegmens : eltolás]---hivatkozás egy Word tipusú elemre MEML[Szegmens : eltolás]---hivatkozás egy Longint tipusú elemre A MEM, MEMW és MEML memóriatömbök lehetôvé teszik, hogy a memória bármely címén levô Byte -ot, két Byte -os szót ill. négy Byte -os dupla szót kiolvassunk ill. felülírjuk Éppen ezért óvatosan használjuk! A szegmens és az eltolás két Word tipusú kifejezés, melyeket a kettôspont választ el egymástól. Direkt portelérést szolgáló elôre deklarált tömbök: PORT [ portcím ]---hivatkozás egy Byte tipusú elemre PORTW[ portcím ]---hivatkozás egy Word tipusú elemre Ezekkel a tömbökkel a 80 X 86 processzorok adatpontjait programozhatjuk:

Írhatjuk, olvashatjuk. A PORT és PORTW egydimenziós tömbök, ahol minden elem egy adatportot reprezentál. A tömb indexe a port címe Amikor a tömb egy kompen sének értéket adunk, akkor írjuk, a tömbre való hivatkozáskor pedig olvassuk a portot. A PORT mindig egy Byte -ot olvas vagy ír. A PORTW 8 bites B/K hardware esetén egymás után két Byte-ot olvas/ír, ha a B/K hardware 16 bites, akkor a szót egyszerre olvassa ill. írja REKORD TÍPUS -- RECORD [ mezôlista ] [ Case [szelektormezô: ] sorszámozott típus of értékleírás:(mezôlista) [, értékleírás: (mezôlista).] END. Egy rekord különbözô tipus ú elemeket fog össze. Általában akkor használjuk, amikor több, egymás melletti adatot egyszerre kell mozgatnunk akár a memória és a memória között, akár a memória és a háttér között. A deklarált adatokat, melyeket a rekord mezôinek nevezünk a Record és End fenntartott szavak közé írjuk. Változó rekord esetén a rekordnak egy

részét többféleképpen osztjuk fel. A CASE fenntartott szó előtti rész a rekord fix része, míg a CASE-el kezdôdô rész a változó rész. A változó részben az adott területnek többféle felosztását is megadhatjuk. Ez olyan esetekben fontos, amikor a rekord fix részétôl függôen, vagy attól függetlenül más -más adatokat szeretnénk tárolni, ill. másképp szeretnénk az adatokra hivatkozni. A rekordnak bármely felosztása bármikor elérhetô, a szelektormezô segíti a programozót a helyes felosztás kiválasztásában. Szelektormezôt akkor érdemes használni, ha különbözô tipusú adatokat tárolunk el a rekordba és azokat feldolgozásnál meg kell különböztetni. A rekordnak van egy változó része amely a fix rész mögött lehet. A változó rész elhagyható. Ha a szelektormezô hiányzik, vagyis csak egy típust adunk meg, akkor annak csak szintaktikai szerepe van, a felsorolt értékeknek nincs jelentôségük. Ezt akkor használjuk, amikor

a tárolt adatoktól függetlenül akarjuk a különbözô felosztásokat használni. Ha egy programrészben több utalás történik egy rekord mezôire, akkor érdemes azt a részt egy WITH minôsítô utasítással összefogni. Ilyenkor ugyanis a mezônevek elé a fordító odateszi a WITH utasításban megadott rekordazonosítót. Ha a rekordnak nincs ilyen mezôje, akkor az eredeti jelentés a mérvadó. A WITH utasításban több rekordazonosító is felsorolható, ekkor az utolsónak a legnagyobb a priorítása. Rekord tipusú konstanst csak a CONST deklarációs részben adhatunk meg, típusos konstans kezdôértékeként. Az elemeket zárójelben, pontosvesszôkkel elválasztva kell leírnunk. Minden elem elé ki kell írni annak azonosítóját kettôsponttal elválasztva. 7. B tétel Egy xBase-kompatibilis (FoxPro) programfelépítése. Láthatóság, érvényesség, eljárások és függvények forrásállományai Az xBase kompatibilis adatkezelő nyelv. Minden

nyelvnek van utasításkészlete. Magas szintű, többféle módon is használható utasítások a relációs adatmodell műveleteihez. Utasítás: hatékony a sztringkezelő műveletek, magas szintű utasítások, hatékony dátumkezelő műveletek. Felépítése: A változók deklarálása típus és érték szerint szabadon, bárhol lehet. Tömböt a DIMENSION és a DECLARE utasítással hozunk létre. Az egyes elemek típusai tetszőlegesek lehetnek Ha @ jelet írunk a változó elé, akkor az értékátadás cím szerinti lesz. Speciális utasítások léteznek az adatbázis tartalmának memóriában illetve tömbökbe való másolására. A paraméterátadás cím és érték szerint lehetséges (SET UDF). Valamennyi memóriaváltozó, kivéve a tömböket, eljáráshíváskor az eljárásnak érték szerint adódik át. A tömbök viszont cím szerint adódnak át. Ha a PRIVATE parancs nincs vonatkoztatva a paraméterre, az eljárásban elvégzett módosítások a tömbben az

eljárás végrehajtódása után is megmarad. Eljárások és függvények: minden eljárás függvény, és minden függvény eljárás. Egy eljárás vagy függvény addig hajtódik végre, míg nem találkozik egy RETURN utasítással, vagy míg egy másik eljárás vagy függvény nem kezdődik. A PASCAL-lal ellentétben a nyelv nem támogatja a strukturális programozást. Erről nekünk kell gondoskodni, mivel az eljárások nem ágyazhatók egymásba. Minden eljárásnak vagy függvénynek Van visszatérési értéke. Ha ezt külön nem határozzuk meg, a visszatérési érték logikai TRUE lesz, egyébként bármi lehet. Fontos megemlíteni, hogy saját függvényeinkre, memóriaváltozóinkra hivatkozhatunk index kifejezéseinkben is. Eljárás vagy függvény hívása: do függvénynév with paraméterlista if függvény (.) = függvény (.) Láthatóság kérdése: ha nincs PRIVATE parancs, akkor nem rejti el, kivéve, ha az eljárás által hívott paraméter megegyezik a

hívó program változójával. A SET PROCEDURE TO eljar.prg az eljarprg forráslistába megadott eljárások globális eljárásokká válnak. Egyszerre csak egy hatásos A memóriaváltozó globálissá tétele a PUBLIC paranccsal történik. A PUBLIC ARRAY kifejezetten hasznos a rövid törzstáblázatok memóriában tartásához. A forrásállományok .prg kiterjesztésű text file-ok A program gyakorlatilag eljárás vagy függvény hívások sorozatából tevődik össze. Egy programon belül valamennyi függvény globális, azaz a futtatáskor bárhonnan elérhető, hasonlóan a C nyelvhez. 8. A1 tétel Elemi programozási tételek IV.: rendezések közvetlen kiválasztással, minimum kiválaztással Rendezés közvetlen kiválasztással A módszer lényege: A rendezendő számok legyenek az A vektor elemei. Az első menetben kiválasztjuk a vektor legkisebb elemét úgy, hogy az A(1) -et összehasonlítjuk A(2) -vel, ., A(N) mindegyikével Ha A(1)-nél kisebb elemet

találunk, felcseréljük őket, vagyis ezt a kisebbet tesszük A(1)-be. Így a menet végére A(1) biztosan a vektor legkisebb elemét tartalmazza majd. Az eljárást A(2)-vel folytatjuk, ezt hasonlítjuk össze az A(3), ., A(N) elemekkel És így tovább. N-1 lépésben a vektor rendezett lesz Algoritmus: Eljárás Ciklus I=1-től N-1-ig Ciklus J=I+1-től N-ig 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. Rendezés minimumkiválsztással A módszer lényege: A felesleges cserék kiküszöbölése érdekében két segédváltozót vezetünk be. Az ÉRTÉK tartalmazza az adott menet beli legkisebb számot, az INDEX pedig annak lelőhelyét vektorban. Algoritmus: Eljárás Ciklus I=1-től N-1-ig INDEX:=I : ÉRTÉK:=A(I) Ciklus J=I+1-től N-ig Ha ÉRTÉK>A(J) akkor ÉRTÉK:=A(J) : INDEX:=J Ciklus vége A(INDEX):=A(I) : A(I):=ÉRTÉK Ciklus vége Eljárás vége. a 8. A2 tétel Eljárás és függvény Turbo PASCAL-ban

paraméterezés összetett adattípussal A Pascal program szerkezete áttekinthetőbb, rövidebb és strukturáltabb, ha a logikailag összetartozó utasításokat alprogramokban foglaljuk. A Pascal nyelvben a procedure kulcsszó, amely az alprogram fejét vezeti be, hasonlóan a program kulcsszóhoz, eljárásnak nevezzük. Lehetőség van saját tervezésű függvény készítésére is. Erre szolgál a function kulcsszó, amellyel szabványos függvényekhez hasonlóan felhasználható függvényeket készítünk. Nagy előnye a függvényeknek és az eljárásoknak, hogy a programban többször, különféle paraméterekkel aktiválhatjuk, ezáltal sok munkát takarítunk meg, mivel nem kell ugyanazokat a programrészeket feleslegesen, kis változtatással többször leírni. A Pascalban két alprogram van: az eljárás és a függvény. A két alprogram közötti fő különbség a hívás módjában jelentkezik. Az alprogram utasításainak végrehajtásához szükséges bemenő

adatokat, valamint azt, hogy az eredmény hol keletkezzem, pontosan meg kell adni. Ezeket az információkat egy ún. paraméterlistán kell megadni. A paraméter listán küldünk és kapunk adatokat, mivel a paramétereken keresztül bonyolódik le az adatcsere. Az alprogram definíciójában a paramétereket formális, az alprogramot hívó utasításban szereplő paramétereket aktuális paramétereknek nevezzük. Fontos szabály, hogy a formális és az aktuális paramétereknek darabszámban, típusban és a megadási sorrendben meg kell egyezniük. A paraméterátadásnak kétféle módja lehet: érték és cím szerinti paraméterátadás. Típusdefinició használata a paraméterlistán Az eljárások és függvények formális paraméterlistáján csak olyan változó lehet paraméter, amelynek külön típusneve van. Ilyen például az integer, real, word, char, string, boolean, stb., de nem használhatjuk az array, set, file, record változókat közvetlenül, ezért

ezekre típust kell definiálni, a type deklaráció segítségével. Ugyancsak felhasználói típust kell létrehoznunk a string[n] típusú paraméterek deklarálásához. type var tömb betuk tfile komplex st12 = = = = array[1.10][110] of real; set of [a.z]; file of integer; record x, y: real; end; = string[12]; st12 : string[12]; a : tomb; f : tfile; abc : betuk; w, y : komplex; fnev : st12; procedure (x:tömb; olv:tfile; fn: st12); . begin . end; 8. B tétel Karakter és stringkezelés a FoxPro 2.5-ben $ Egy karaktersorozat keresése egy másikban. A különbséget kis és nagybetű között. <kifC1>$ <kifC2> ALLTRIM() Egy karakter bevezető és záró szóközének értéke egy karakteres kifejezés. ALLTRIM(<kifC>) keresés levágása. nem tesz Visszaadott ASC() Egy karakter ASCII kódját határozza meg. Visszaadott értéke numerikus, 0 és 256 közötti szám lehet. ASC(<kifC>) CHR() Egy ASCII kód karakteres formáját adja meg.

Visszaadott karakter, amely az ASCII kódnak felel meg. CHR(<kifN>) értéke egy ISALPHA() Azt vizsgálja, hogy egy karaktersorozat betűvel Visszaadott értéke igaz (.T) vagy hamis (F) ISALPHA(<kifC>) kezdődik-e. ISDIGIT() Azt vizsgálja, hogy egy karaktersorozat számmal Visszaadott értéke igaz (.T) vagy hamis (F) ISDIGIT(<kifC>) kezdődik-e. LEFT() A karaktersorozat meghatározott részét adja vissza számítva. LEFT(<kifC>,<kifN>) LEN() A karaktersorozat hosszát byte-ot 0-nak számol. LEN(<kifC>) adja meg numerikus a bal oldaltól egészként. Minden LIKE() Két karakteres kifejezést hasonlít össze. Nem tesz különbséget a kis és nagybetűk között. Visszaadott értéke igaz vagy hamis lehet. LIKE(<kifC1>,<kifC2>) LOWER() A megadott karaktersorozatot kisbetűssé betűknél végzi el a műveletet. LOWER(<kifC>) konvertálja. Csak a REPLICATE() Egy karaktersorozat ismétlése kifN -szer. Maximum 64000

karakter hosszan lehet megtenni. Ha 0 -t adunk meg, akkor a string „” lesz. REPLICATE(<kifC>,<kifN>) RIGHT() A karaktersorozat meghatározott részét adja vissza a jobb oldaltól számítva. RIGHT(<kifC>,<kifN>) RTRIM() Egy karaktersorozat jobb oldaláról levágja a szóközöket. RTRIM(<kifC>) SPACE() Egy karakteres változót tölt fel szóközökkel. Visszaadott érétke egy string kifN darab szóközzel. SPACE(<kifN>) STR() Egy numerikus kifejezést karakteressé alakít. STR(<kifN1>[,<kifN2>[,<kifN3>]]) TRANSFORM() Tetszőleges adattípust formázott karaktersorozattá alakít. TRANSFORM(<kifx>,<kifC>) UPPER() Adott karaktersorozatot nagybetűssé konvertál. UPPER(<kifC>) 10. A1 tétel Elemi programozási tétele XI.: rendezés buborékos módszerrel A buborékos rendezés alapgondolata a szomszédos elemek cseréje. Az első menetben a rendező A vektor végéről indulva minden elemet

összehasonlítunk az előtte lévővel. Amennyiben rossz sorrendben vannak, felcseréljük őket. Az első menet végére a legkisebb elem biztosan a helyére kerül. Minden további menetben ismét a vektor végéről indulunk, de egyre kevesebb hasonlításra van szükségünk, mert a vektor eleje fokozatosan rendezetté válik. Algoritmus: Eljárás Ciklus I=2-től N-ig Ciklus J=N-től I-ig -1-esével Ha A(J-1)>A(J) akkor A:=A(J-1) A(J-1):=A(J) A(J):=A Elágazás vége Ciklus vége Ciklus vége Eljárás vége. 11. A1 tétel Elemi programozási tételek IV.: másolás, kiválogatás Kiválogatás tétele Általános feladat: egy N elemű sorozat összes T tulajdonsággal rendelkező elemét kell meghatározni. Gyűjtsük a kiválogatott elemek sorszámait a B() vektorban! 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. 11. A2 tétel Eljárások és függvények fogalma, paraméterlista,

formális és aktuális paraméterek, érték és cím szerinti paraméterátadás. Eljárások, függvények A Pascal program deklarációs részében alprogramokat deklarálhatunk. Az alprogram (blokk) utasítások összessége, amelyeket a program bizonyos pontjairól aktivizálhatunk. Az alprogramok deklarációs részei tartalmazhatnak újabb alprogram-deklarációkat is. Alprogramot akkor írunk, ha: - bizonyos tevékenység többszõr elõfordul a programban ugyanúgy,vagy más adatokkal - a túl nagy programot tagolni,olvashatóságát növelni szeretnénk. 25 -30 sornál nagyobb programrészt nehéz áttekinteni, és a struktúrált programkód elõállítása is nehézkessé válik. A Turbo Pascal-ban az alprogramok két fajtája ismeretes : az eljárás (procedure) és a függvény (function). Az eljárás egyszerûen végrehajtódik, amikor a neve utasításként megjelenik, majd a vezérlés a hívás utáni utasításra tér vissza. Függvény esetében nem csupán az

utasítások végrehajtásáról van szó, hanem maga a hivatkozás kap értéket, s ez a függvényérték bármilyen kifejezésben operandusként szerepelhet. A visszaadott érték típusa elõre meghatározott. Eljárások Az eljárás szerkezete hasonló a program szerkezetéhez, különbség csak az eljárás fejében, a “Procedure” kulcsszóban van. A záró End után pont helyett pedig pontosvesszôt írunk. Eljárásfej: PROCEDURE eljárás-azonosító (formális paraméterlista); Deklarációs rész: LABEL. CONST. TYPE. VAR. PROCEDURE. FUNCTION. Blokk: Begin utasítások End; Formális paraméterlista ([Var]) azonosító (,azonosító.):típusazonosító ( ; ([Var]) azonosító (,azonosító.):típusazonosító) A formális paraméterlista elhagyható. Ha a formális paraméterlista, vagy akár csak egy paraméter elôtt is, szerepel a “Var” kulcsszó, az ilyen paraméterátadást címszerinti átadásnak nevezzük (változó azonosító ð memória cím), elhagyása

esetén pedig érték szerinti paraméter átadásnak nevezzük. A címszerinti paraméter-átadás a hívó és hívott modul között mindig kétirányú, az átadott paraméter értéke (pld. annak megváltozásával) visszakerül a vívó modulhoz, míg az érték szerinti hívás csak egyirányú, a hívótól a hívott modul felé irányul. Aktuális paraméterlista kifejezés/változó (,kifejezés/változó.) A paraméterátadás a formális paraméterlista felsorolásának soorendjében történik. Az aktuális paraméterek típusának rendre meg kell egyeznie a formális paraméterlistában megadottakkal. Címszerinti paraméterátadáskor az aktuális paraméter csak deklarált változó lehet, míg érték szerinti átadáskor a formális paraméter tipusának megfelelô konstans, változó, függvény vagy kifejezés is lehet. Az eljárás vagy programblokk ismeri: - az eljárás vagy program deklarációs részében levõ eljárásokat, de azok eljárásait nem -

ugyanazon deklarációs részben már elõbb deklarált eljárásokat - az õt tartalmazó eljárásokat - saját magát (rekurzív hívás) Függvények A függvény hívásra ugyanúgy végrehajtódik, mint egy eljárás. A különbség az, hogy a függvény azonosítója egy érték: a függvény visszatérési értéke. Míg az eljárás hívása utasításként viselkedik, a függvényt kifejezésekben használhatjuk, péld ául értékadó utasítás jobb oldalán, vagy aktuális paraméterként. Például a Write egy eljárás, a Sin egy függvény: Write(Sin(5)). A függvény szerkezete hasonló az eljáráséhoz. Feje a következõ: FUNCTION függvényazonosító (formális paraméterlista):típusazonosító; Típusazonosító csak sorszámozott, valós, karakterlánc vagy mutató lehet. A függvény deklarációs része, valamint a formális és aktuális paraméterlista ugyanaz, mint az eljárásnál. A függvény blokkjában a függvényazonosítónak értéket kell adni

egy értékadó utasítással. A függvény visszatérési értéke az utoljára adott érték lesz. Ha a függvénynek nem adunk értéket, akkor az definiálatlan lesz. Ha a függvényazonosítót nem az értékadó utasítás baloldalán használjuk, akkor az a függvény újbóli hívását eredményezi (rekurzív hívás), és így a szintaktika megköveteli az aktuális paraméterlistát, ha van. Egyébként könnyen elõfordulhat a verem túlcsordulása. Függvény hívása: Függvényazonosító (aktuális paraméterlista) Rekurzív hívás Egy eljárás vagy függvény önmagából való hívását rekurzív hívásnak nevezzük. Ilyenkor a visszatérési címek, lokális változók újból és újból a verembe kerülnek. Tehát a verem egyre csak telik, s ha nem vigyázunk, akkor könnyen betelik, azaz túlcsordúl (Stack overflow). Rekurzió esetén meg kell adni a lehetõséget arra, hogy a verem kiürüljön. A verem akkor tud csökkeni, amikor az eljárás vagy

függvényblokk záró End -jére kerül a vezérlés. Ekkor megszûnnek a lokális változók, s a visszatérési cím alapján folytatódik a programvezérlés. Ha tehát az End elõtt mindig újra hívjuk a rutint, a verem csak telni tud. Általában egy feltételtõl függõen szokás újra hívni a rutint, majd ha az a feltétel már nem teljesül, a program vissza tud keveredni az induló programszintre. A cím szerinti és érték szerinti paraméterátadás a PASCAL nyelvben Érték szerinti paraméterátadás: Eljárás deklarálás: PROCEDURE EljNév ( Változó : Típus ) ; Eljárás hívása: EljNév ( Változó | Konstans | Szám ) ; A paraméter lehet egy változó, elõre deklarált konstans vagy konkrét szám. Az EljNév-en belül a változó nem képes megváltozni. Egy irányú az adatforgalom Cím szerinti paraméterátadás: Eljárás deklarálás: PROCEDURE EljNév ( VAR változó : Típus ) ; Eljárás hívása: EljNév ( változó ) ; Az EljNév -en belül a

változó kaphat új értéket, mert az eljárás hívása során a változónak nem az értéket adjuk át, hanem az abszolút címet. Az adatforgalom kétiranyú. A paraméter csak változó lehet, nem lehet konkrét szám vagy konstans. 11. B Környezeti paraméterek beállítása a FoxPro-ban SET BELL A SET BELL a jelzőhang be/ki kapcsolását szabályozza, illetve itt adható meg. SET CARRY A SET CARRY a mezőértékek átvitelét az új rekordokba segíti elő. Alapértelmezése OFF. SET CENTURY A SET CENTURY ON állásban a dátumoknál kijelzi az évszázadot is. Ekkor a dátum hossza 10 karakter. OFF állásban csak az évszám utolsó két karaktere jelenik meg. SET COLOR A SET COLOR parancsok a színek beállítását határozza meg. A FoxPro színsémákkal, színpárokkal dolgozik. A színpárok a hátteret és a megjelenítési színt adják meg. Ezeknél a + a fényerőt, a * a villogást jelzi. A színpárlista 1-10 színpárt tartalmaz. A színsémákat a

FOXUSER.DBF állomány tartalmazza SET DATE A SET DATE -val tudjuk a dátumformát meghatározni. A SET DATE hatása a teljes programra érvényes, függetlenül a parancs kiadási helyétől. Alapértelmezése az AMERICAN forma (mm/dd/yy) SET DELETED A SET DELETED a törlésre kijelölt rekordok szűrését végzi el. On állásban elrejti a törlésre kijelölt rekordokat. Az OFF figyelembe veszi a törlésre kijelölt rekordokat is. Ez az alapértelmezés. A SET DELETED hatását munkaterülettől függetlenül kifejti. SET EXACT A SET EXACT-tal a karakteres kifejezéseket pontosan össze lehet hasonlítani. A SET EXACT parancs helyett használható még a = = műveleti jel is. SET RELATION A SET RELATION két vagy több munkaterület kulcsérték szerinti összekapcsolását végzi el. Az argomentum nélküli SET RELATION TO megszünteti a munkaterület összes érvényben lévő relációs kapcsolatát. SET SHADOWS A SET SHADOWS -szal az árnyákolást lehet ki- és bekapcsolni az

ablakoknál. Az alapértelmezés ON SET SKIP A SET SKIP 1:N relációs kapcsolat létesítésére alkalmas két adatbázis között. Az 1:N relációs kapcsolat lezárása a paraméterek nélkül megadott SET SKIP TO paranccsal lehetséges. SET SYSMENU A SET SYSMENU a rendszermenü -sor ellenőrző figyelését segíti elő. On megadása esetén a rendszermenü elemei elérhetőek a program végrehajtása közben, ha a billentyűzetről vár inputot. A rendszermenü nem látható, de az ALT, F10 vagy az egér dupla kattintásával láthatóvá tehető. Az ON az alapértelmezés SET TALK A SET TALK az üzenetek megjelenítésére, letiltására használható. Letiltani a SET TALK OFF-fal lehet. 12. A1 tétel Elemi programozási tételek V.: metszet, unió A metszetképzés tétele Általános feladat: Rendezésünkre áll egy N és egy M elemű halmaz az A() és a B() vektorban ábrázolva. Készítsük el a két halmaz metszetét a C() vektorba! Algoritmus: Eljárás CN:=0 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) Ciklus vége Eljárás vége. Unióképzés tétele Általános feladat: Rendezésünkre áll egy N és egy M elemű halmaz az A() és a B() vektorban ábrázolva. Készítsük el a két halmaz egyesítését a C() vektorba! 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) Ciklus vége Eljárás vége. 12. B tétel Grafikai elemek programozása Turbo PASCAL-ban. A grafikus üzemmód,alakzatok rajzolása. Számítógépünkhöz több féle grafikus kártyát csatolhatunk. Ennek grafikus üzemmódban a felbontás és színeinek száma (ezek a legjellemzôbb adatai) eltérôek . megfelelôen a grafikus kártya A legismertebb grafikus kártyák : CGA ( Color Graphics Adapter ) 320 * 200 képpont, 16 szín 640 * 200

képpont, 2 szín (Monochrome) MCGA ( Multi Color Graphics Adapter ) 320 * 200 képpont, 256 szín TANDY 320 * 200 képpont, 16 szín HERCULES (vagy röviden HERC ) 720 * 348 képpont, Monochrome ( 2 szín ) EGA ( Enached Graphics Adapter ) 640 * 350 képpont, 16/64 szín VGA ( Video Graphics Array ) 640 * 480 képpont, 16/64/256 szín 800 * 600 képpont, 256 szín (SVGA 512 KB memória) 1024 * 768 képpont, 256 szín (SVGA 1 MB memória) XGA (eXtended Graphics Array) Felbontása és színek száma azonos a VGA -val, de 90%-kal, Windows-ban 50%-kal nagyobb. sebessége DOS -ban A Pascal a 2.0 verzió óta támogatja a grafika kezelését Akkor csupán egy-két eljárás segítette a programozó munkáját, míg a Pascal 5.5 -ben már 79 eljárás illetve függvény hivatott ugyanerre a célra. Grafikus file-ok : GRAPH.TPU graph unit,ez tartalmazza a grafikus eljárásokat ill. függvényeket *.BGI - ezek tartalmazzák a különbözô grafikus kártyákhoz tartozó grafikus

meghajtókat *.CHR - a grafikus karakterkészletet tartalmazzák A számítógép kétféle üzemmódot használhat, a karaktereset és a grafikust. Alapértelmezésben a karakteres képernyôt látjuk, melynek a legkisebb egysége a karakter. A grafikus képernyô legkisebb egysége a képpont (pixel). Ahhoz hogy a grafikus képernyôn tudjunk dolgozni elôször is az adatleíró részben meg kell hívni a Graph unitot, aztán inicializálni kell azt,amit az InitGraph (grafikus meghajtó, grafikus mód, az aktuális .BGI file -t tartalmazó könyvtár neve) eljárással tudunk megtenni. A grafikus meghajtó és a grafikus mód típusát a DetectGraph (graf.megh, graf.mód) eljárással tudjuk lekérdezni Ha nincs grafikus meghajtó a gépben, akkor grafikus meghajtó= -2 lesz. Ha befejeztük a munkánkat a grafikus képernyôn, akkor a CloseGraph utasítással zárjuk be azt. Vonalas geometriai alakzatok: Ezek olyan alakzatok, melyek rajzolásához elegendô egy vonal. Itt

lehetôség nyílik az egyenes rajzolási módjának beállítására is (SetLineStyle eljárás). Vonalrajzoló eljárások a következôk: Arc - Körív Circle - Kör Drawpoly - Polinom Ellipse - Ellipszis Line, LineTo, LineRel - Egyenes Rectangle - Téglalap Festett geometriai alakzatok: Ide azok az eljárások sorolandók amelyek körvonala zárt belül pedig egy színnel vagy mintával vannak kitöltve. Létrehozásuk két féle módon történhet: vagy megrajzoljuk a körvonalat,és azt festjük ki (FloodFill eljárás), vagy pedig eleve festett alakzatokat rajzolunk. Ez utóbbit a következô eljárásokkal tehetjkük meg: Bar - Téglalap Bar3d - Téglatest FillEllipse - Ellipszis FillPoly - Sokszög Pieslice - Körcikk Sector - Elipsziscikk Szöveg a grafikus képernyôn: Grafikus képernyôre a szöveget másképp kell írni mint a karakteresre. A szöveg pozicionálása pixelenként történik, a kiválasztott pixelhez kilencféle módon illeszthetô a kiíratandó szöveg,

amit beállíthatunk a SetTextJustify eljárással. További eljárások: SetTextStyle: Beállítja az aktuális karakterkészlet típusát és méretét. SetUserCharSize: A karakter magasságát és szélességét állítja be. TextHeight: Megadja a szöveg magasságát (pixelben). TextWidth: Megadja a szöveg szélességét(pixelben). OutText: Kiírja a megadott szöveget a kurzor aktuális pozíciójától. OutTextXY: A megadott koordinátájú ponttól írja ki a szöveget. Az animáció: A mozgó alakzatok létrehozására is szolgál néhány eljárás. A számítógép a benne lévô grafikus kártyától függô en, több képernyônyi adatot is képes egyszerre tárolni a képernyômemóriában (az általános az 1 vagy 2 képernyôlap). GetImage: A képernyô megadott részét elmenti egy bufferbe. PutImage: Képmezõ ráhelyezése a képernyõre. SetActivPage: Kijelöli azt a képernyôlapot,amelyikre dolgozunk. SetVisualPage:Láthatóvá teszi az adott grafikus lapot.

Egyébb fontos utasítások : ClearDevice: Képernyô törlés SetBkColor: Háttérszín beállítása SetColor: Irószín beállítása GetX,GetY: A kurzorpozició lekérdezése MoveTo: Kurzormozgatás 13. A1 tétel Elemi programozási tételek VII.: rendezés egyszerű beillesztéssel A rendezést úgy végezzük, mintha kártyáznánk és kezünkbe egyesével vennénk fel az asztalról a kiosztott lapokat. Az éppen felvett lapnak megkeressük a kezünkben lévő, már rendezett sorozatban a helyét úgy, hogy közben a nála nagyobbakat egy hellyel elcsúsztatjuk, végül beillesztjük a felvett lapot a neki megfelelő helyre. N elem esetén a végső sorrend kialakításához N-1 menetre van szükség. Eredeti: 64 56 8 42 5 12 16 1. menet után: 56 64 8 42 5 12 16 2. menet után: 8 56 64 42 5 12 16 3. menet után: 8 42 56 64 5 12 16 4. menet után: 5 8 42 56 64 12 16 5. menet után: 5 8 12 42 56 64 16 . . . 15. menet után: 3 5 7 8 12 16 22 Algoritmus: Eljárás Ciklus

J=2-től N-ig I:=J-1 : A:=A(J) Ciklus amíg I>0 és A<A(I) A(I+1):=A(I) : I:=I-1 Ciklus vége A(I+1):=A Ciklus vége Eljárás vége. 40 40 40 40 40 40 3 3 3 3 3 3 31 31 31 31 31 31 47 47 47 47 47 47 22 22 22 22 22 22 24 24 24 24 24 24 33 33 33 33 33 33 7 7 7 7 7 7 46 46 46 46 46 46 24 31 33 40 42 46 47 56 64 13. A2 tétel A PASCAL program blokk-szerkezete, a változók érvényességi köre, globális és lokális változók. Szokás a deklarációs és a végrehajtási részt együttesen blokknak is nevezni. Ilyenformán úgy is mondhatjuk,hogy a programok és az alprogramok fejbõl és blokkokból állnak, a blokkok pedig deklarációs és utasítási részekbõl. A programblokk a deklarációs résszel kezdõdik, ahol minden, a blokk szempontjából lokális változót deklarálni kell. Ez azt jelenti, hogy az itt deklarált változók a blokkon belül, valamint az adott blokkot tartalmazó valamennyi blokkon belül és csakis ezeken belül használhatók. Az

ilyen változókat az adott blokkra nézve lokális változóknak nevezzük. Azokat a változókat pedig, amelyek egy olyan külsô blokkban lettek deklarálva, mely tartalmazza az adott blokkot, az adott blokkra nézve globális változóknak nevezzük. A végrehajtási rész tartalmazza a szûkebb értelemben vett utasítások sorozatát. A program sorai és utasításai különbözô fogalmakat jelentenek. Bár az editor egy sorba maximum 4000 karaktert enged írni, a forrásprogram egy sora legfeljebb 127 karaktert tartalmazhat, különben szintaktikai hibát vétünk. Globális változók: az egész programra vonatkozó változók, melyek a program elején születnek és a program végéig élnek. A memoriát a program futása során végig terhelik! Lokális változók: csak egy adott alprogramban, vagy egy adott unit élnek. A program során csak erre az idôre terhelik a memóriát -ban A TP -ban minden változó valamilyen tipusú. A tipusok között vannak a redszerbe

beépített tipusok, valamint mi magunk is létrehozhatunk tipusokat. A változók deklarációját a var szó vezeti be. A változók deklarálása csak az adott blokkon belül, valamint minden, az adott blokkon belül lévô blokkban érvényes. Ha a változót újra deklaráljuk, a külsô blokkbeli deklarációtól eltérôen, akkor a változó a belsô blokkban az új deklarációnak megfelelô tipust veszi fel, új, lokális változóként viselkedik. A belsô blokk befejezésével, a külsô blokkba visszatérve, a változó ismét a külsô blokkban meghatározott deklarációnak megfelelô lesz. Ha nem deklaráljuk újra a változót a belsô blokkban is érvényes, a fõprogramban deklarált, változó lesz. A föprogramban deklarált, globális, statikus változók az adatszegmensben (D Seg) a lokális változók a stack szegmensben (S Seg) a konstansok pedig a kódszegmensben (C Seg) vannak. Ez azt jelenti, hogy szegmenscímük rendre a DS, BP, CS regiszterekben van,

offsetjük pedig ezekhez relatív. 13. B tétel A lokális és globális változók alkalmazási szabályai FoxProban A globális változókat a FoxPro -ban a PUBLIC parancs segítségével tudjuk létrehozni. Szintaxisa : - változó esetén: PUBLIC <változólista> - tömb esetén: PUBIC [ARRAY]<tömb1>(<kifN1>[,<kifN2>] )[,<tömb2>(<kifN3>[,<kitN4>])]. <változólista>: A globális változó neve. Egymástól vesszővel elválsztva több globális változó deklarálható egyidejűleg egy PUBLIC paranccsal. [ARRAY] <tömb1> (<kifN1> [,<kifN2>]) [,<tömb2> (<kifN3> [,<k itNl4>])) - egy vagy több globális tömb neve. <kifN1> - az egydimenziós elemeinek száma; <kifN1>, <kifN2> kétdimenziós tömb definiálása. A PUBLIC utasítás segítségével olyan változókat deklarálhatunk, amelyek érvényessége a program összes eljárására és felhasználói függvényére

kiterjed . A Parancsablakban létrehozott minden változó automatikusan GLOBÁLIS lesz . A lokális változók deklarálásában FoxPro-ban a PRIVATE parancs szolgál. Szintaxisa : - változó és tömb esetében is uganaz : PRIVATE <memóriaváltozó-lista> PRIVATE ALL [LIKE <maszk> | EXCEPT <maszk>] <memóriaváltozó-lista> - a lokális változó vagy tömb neve. PRIVATE ALL LIKE <kijelölés> - a <kijelölés>figyelembevételével definiálja a lokális memóriaváltozókat, illetve tömböket. A <kijelölés> tartalmazhat helyettesítô ketraktereket (?. *) is. PRIVATE ALL EXCEPT <maszk> - a <maszk> szerintiek kivételevel definiálja a tárolandó memóriaváltozókat. Egymástól vesszôvel elválasztva több lokális változó és deklarálható egyidejűleg egy PRIVATE utasítással. tömb A PRIVATE utasítás segítségével határozhatjuk meg azoknak a változóknak és tömböknek a körét, amelyek egy hívó

programban már deklarálva lettek, de a konkrét programban, eljárásban ugyanazokkal a nevekkel más értékeket kivánunk ezeknek átadni, majd a hívó programmal visszatéréskor az eredeti értekeket kívánjuk újra felhasználni. A PRIVATE utasítás nem hoz létre változót, csupán elfedi az aktuális program elôl a hívó programokban defilniált változókat. 14. A1 tétel Elemi programozási tételek VIII.: rendezés Shell-módszerrel A Shell -módszer nem foglalkozik egyszerre minden rendezendő elemnek, csak az egymástól adott távolságra lévőkkel. A rendezés most is több menetben történik. Minden menet elején meghatározunk egy úgynevezett lépésközt, a D -t, amely azt jelenti, hogy az adott menetben a vektor egymástól D távolságra lévő elemeit rendezzük. Az induló lépésköz meghatározása úgy történik, hogy a rendezéshez szükséges menetek száma körübelül log2N legyen. Algoritmus: Eljárás INT(LOG(N)/LOG(2)) D:=2 Ciklus I:=1

Ciklus amíg I<=D és I+D<=N Ciklus J=I+D-től N-ig D-esével A:=A(J) : B:=J-D Ciklus amíg B>0 és A<A(B) A(B+D):=A(B) : B:=B-D Ciklus vége A(B+D):=A Ciklus vége I:=I+1 Ciklus vége D:=INT(D/2) amíg D>0 Ciklus vége Eljárás vége. 15. A1 tétel Elemi programozási tételek IX.: A backtrack algoritmus Általános feladat: adott N sorozat, amelyek rendre M(1), M(2), . elemszámúak. Ki kell választani mindegyikből egy-egy elemet úgy, hogy az egyes sorozatokból való választások más választásokat befolyásoljanak. Tulajdonképpen ez egy bonyolult keresési feladat: egy adott tulajdonsággal rendelkező szám N-est kell keresni. Algoritmus: Eljárás I:=1 Ciklus amíg I>=1 és I<=N Ha VAN JÓ ESET(I) akkor I:=I+1 : X(I):=0 különben I:=I-1 Elágazás vége Ciklus vége VAN:=I>N Eljárás vége. VAN JÓ ESET(I): Ciklus X(I):=X(I)+1 amíg X(I)<=M(I) és ROSSZ ESET(I,X,(I)) Ciklus vége VAN JÓ ESET:=X(I)<=M(I) Eljárás vége. ROSSZ

ESET(I,X(I)): J:=1 Ciklus amíg J<I és (J,X(J)) nem zárja ki (I,X(I))-t J:=J+1 Ciklus vége ROSSZ ESET:=J<I Eljárás vége. 15. A2 tétel Az Objektum Orientált Programozás (OOP) szerepe és eszközei a Turbo PASCAL-ban. Az öröklődés fogalma Az objektum olyan képi megjelenítésű programelem, amelynek adatai (mezői) és működtetési metódusai (eljárásai) vannak. Adatok pl: • színek, • méretek, • képernyőn való helyzet, • állapot Működések pl: • megszületés, létrehozás, • megjelenítés, Init, • forgatás, • mozgatás, eltolás, • állapotváltás, • eltűntetés, elrejtés, Az OOP módszer lényege, szerepe Három féle felvitel: 1., zártsági: a mozgatást végző metódusok csak az objektumon belül végeznek műveleteket, ezek adatain hajtódnak végre, tehát mindig a saját adatokon történik a műveletvégzés. 2., öröklődés: szülő objektum (Parent) -> származtatott objektum (Child) TYPE ObjTipAzonosito =

Object[(SzülőobjektumTipus)]; mezőlista metóduslista [PRIVATE mezőlista metóduslista] END; 3., Többalakúság (polimorfozis) Bizonyos metódusok, ha úgy rendelkezünk, több objektumhoz is tartozhatnak. Az ilyen metódusokat virtuális metódusoknak nevezzük. Az, hogy egy virtuális metódus melyik objektumhoz tartozik, nem a fordításkor dől el, hanem a program futási ideje alatt. Definíció: Procedure MetódusNév[(ParTip)]; VIRTUAL; 17. A2 tétel A fordítási direktívák a Turbo PASCAL-ban Fordító direktívák: A fordítóprogramnak adott speciális utasítások, amelyekkel a fordítás körülményeit és a keletkező lefordított program tulajdonságait megváltoztathatjuk. A direktívák csoportosítása: - Kapcsoló direktívák: csak két állapotuk lehet, aktív és passzív, ezt a direktíva neve után tett + ill. - jellel tüntetjük fel Szintaxisuk a következô: a direktívákat kapcsos zárójelbe tesszük, de megkülönböztetésül a kommentektől a

nyitó zárójel { után dollár jel $jelzi, hogy ez direktíva. Ezután a direktíva neve, majd az állapotot jelzô + vagy - jel következik. Például: {$I+} vagy {$B-} Egymás után több direktívát is felsorolhatunk, mint például: {$I+,B -,N+}. A kapcsoló direktívák globálisak vagy lokálisak lehetnek: - Globális kapcsoló direktívák: az általuk definiált tulajdonságok az egész program vagy unit területére érvényesek. Közvetlenül a programfej vagy unitfej után kell elhelyeznünk ôket; hatásuk a program, ill. unit egészére vonatkozik. (Globális direktívák: A, D, E, L, M, O) - Lokális kapcsoló direktívák: e direktívákat bárhol elhelyezhetjük a program és a unit területén, sôt, hatásukat bármikor módosíthatjuk. (Lokális direktívák: B, F, I, R, S, V) - Paraméteres direktívák: a direktíva neve után paraméterek következnek, például memóriaméret vagy egy filenév, ez esetben a direktíva és a paraméterek együttesen

specifikálják az utasítást a fordítónak. Szintaxisuk: {$ <direktívanév> <paraméter 1>.<,paraméter n>} (Paraméteres direktívák : I, L, M, O ) - Feltételes direktívák: a fordítás menetét specifikálják. E direktívákkal elérhetô, hogy a fordítás a forrásfájlnak csak egy, valamely feltétel kiértékelésétôl függô, részére terjedjen ki. Két szerkezetet használhatunk: {$IFxxx feltétel} . . {$ENDIF} , vagy {$IFxxx feltétel} . . {$ELSE} . . {$ENDIF} (Feltételes direktívák: IFDEF, IFNDEF, IFOPT, DEFINE, UNDEFINE. A feltételes direktívák nem tartoznak szorosan a tananyaghoz, ezért elég csak megemlíteni ôket) Fordítási direktívák B direktíva: logikai kifejezés kiértekelése. Lokális kapcsoló direktíva, alapértelmezése passzív. Aktív állapotban a logikai kifejezések kiértekelése teljes mértékben, passzív állapotban csak a végeredmény egyértelművé válásáig történik. Az aktív állapot

beállítása tesztelésnél célszerű, de a már tesztelt programban a gyorsabb futás érdekében célszerű kikapcsolni. E direktíva: aritmetikai processzor emulálása. Globális kapcsoló direktíva, alapértelmezése aktív. Aktív állapotban a numerikus processzor emulálásra kerül, hiszen co -processzor hiányában csak így használhatjuk a real típustól különbözô valós típusokat (single, extended, double, comp). Az E direktíva aktív állapotának előfeltétele az N direktíva bekapcsolása. Tehát ha nincs matematikai társprocesszor, és használni szeretnénk a kiterjesztett valós típusokat akkor az E és az N direktívát is be kell kapcsolnunk, ha van akkor az E direktívát kapcsoljuk ki. I direktíva mint I/O ellenőrzés. Lokális kapcsolódirektíva, alapértelmezése aktív. Aktív állapota mellett input -output hiba esetén a program futása megszakad, és a vezérlés visszakerül az operációs rendszerhez. Passzív állapot es etén az

IORESULT függvény segítségével kezelhetjük az I/O hibákat. Hiba esetén nem áll le a program futása, de minden I/O művelet felfüggesztôdik az IORESULT meghívásáig. A függvényt meghívva megkapjuk a hibára jellemzô hibakódot. I direktíva mint include -file beszerkesztése. Segítségével include (beszúrt) fájlokat szerkeszthetünk be a forrásprogramunkba. Az include fájlok forrásnyelvű programrészletek, melyek a fordítás alatt a programunkhoz szerkesztôdnek. Használata: {$I <fájlnév>} A kiterjesztés alapértelmezése .PAS, hiánya esetén a rendszer ezt feltételezi E direktíva nem állhat BEGIN és END között, maximálisan 15 include-file ágyazható egymásba. N direktíva: numerikus processzorhoz. Globális kapcsoló direktíva, alapértelmezése passzív. Passzív állapotban csak a real valós típust használhatjuk. Ha a kiterjesztett valós típusokat akarjuk használni, akkor kapcsoljuk be, és az E direktíva állapotától

függôen, vagy a co processzor fog működni, vagy pedig csak annak emulálására kerül sor. R direktíva: érvényességi tartomány ellenôrzése. Lokális kapcsoló direktíva, alapértelmezése passzív. Aktív állapotban futás közben ellenôrzésre kerül az indexek érvényességi, illetve a skaláris és résztartomány típusok értelmezési tartománya. Túlcsordulás esetén a program futása hibaüzenettel megszakad. Az aktív állapot beállítása tesztelésnél célszerű, de a már tesztelt programban a gyorsabb futás érdekében célszerű kikapcsolni. 18. A1 tétel A rekurzió fogalma. Fabejárások rekurzív algoritmusai Rekurzió: rekurzívnak nevezünk egy függvényt vagy egy eljárást, ha a végrehajtás során önmagát meghívja. A rekurzió végrehajtása során egy úgynevezett bázisértéket vagy báziskritériumo t adunk meg, amikor a függvény vagy eljárás már nem hívja meg önmagát. Fabejárások rekurzív algoritmusai

KBJ-bejárás(MUT): Ha MUT<>0 akkor ki: ADAT(MUT) KBJ-bejárás(BAL(MUT)) KBJ-bejárás(JOBB(MUT)) Elágazás vége Eljárás vége. BKJ-bejárás(MUT): Ha MUT<>0 akkor BKJ-bejárás(BAL(MUT)) ki: ADAT(MUT) BKJ-bejárás(JOBB(MUT)) Elágazás vége Eljárás vége. BJK-bejárás(MUT): Ha MUT<>0 akkor BJK-bejárás(BAL(MUT)) BJK-bejárás(JOBB(MUT)) ki: ADAT(MUT) Elágazás vége Eljárás vége. 18. A2 tétel Sorolja fel a file-típusokat Turbo PASCAL-ban. Ismertesse a text file-ok alkalmazásának sajátosságait Turbo PASCAL-ban. A Turbo PASCAL -ban ismerünk szöveges file-okat, típusos állományokat és típus nélküli állományokat. Szöveges file: TEXT A s zöveges file olyan sorokból épül fel, amelyek karaktereket tartalmaznak, és a sort a kocsi vissza/soremelés (CR/LF) vezérlőkarakterek zárják. A CR/LF karakterek a sorok végét jelzik a file -ban. A szöveges file-okat tetszőleges szövegszerkesztővel létrehozhatjuk illetve

módosíthatjuk. A TEXT file -ok az elérésük és használatuk szempontjából a szekvenciális file -okhoz tartoznak. Az egyes sorokat mindig a legelső sortól kezdve egyesével olvashatjuk illetve írhatjuk. Kivételt képez a hozzáírás művelete, mivel ekkor az írás a már meglévő file utolsó sora után kezdődik. A szöveges file-t vagy csak írhatjuk, vagy csak olvashatjuk. Művelet Deklaráció Irás/olvasás jellege Összerendelés Nyitási módok Írás Olvasás Pozicionálás Pozíció- és fileméret Text Var f:text; egy sor (CL/LF) csak írható vagy csak olvasható, szekvenciális Assign(f,filenév) Reset: csak olvasásra Append: csak írás, bővítés a file végére Rewrite: csak írás, felülírás Write(f,sor) nem tesz a sor végére CR/LF jelet Writeln(f,sor) tesz a sor végére CR/LF jelet Read(f,sor) nem emel sort Readln(f,sor) emel sort Seekeof(f) 18.B tétel Feltételes szerkezetek szintaxisa a Turbo PASCAL-ban és a FoxPro-ban Turbo PASCAL Az IF

utasítás Az IF utasítás kétirányú feltételes elágazás. Az a szerepe, hogy bizonyos utasítás(ok) végrehajtása csak valamilyen feltétel teljesülése esetén következzen be. A feltétel egy logikai változó vagy kifejezés, amely az IF szó után áll, ezt a THEN szó követi, majd egy vagy több utasítás. Ha ezek száma egynél több, akkor BEGIN-END blokkba zárjuk ôket. Ha a feltétel nem teljesül, az említett utasítás(ok) nem kerül(nek) végrehajtásra. Ez esetben az IF szerkezetet ; zárja. Ha azt is definiálni akarjuk, hogy mi történjen akkor, ha a feltétel nem teljesül, akkor az ; elmarad, helyére az ELSE szó kerül, majd egy másik utasítás , illetve blokk következik, végül pedig ; zárja az IF szerkezetet. A feltétel nem teljesülése esetén tehát az ELSE utáni ág hajtódik végre. Ez esetben az IF szerkezet formája : IF logikai kifejezés THEN utasítás1 ELSE utasítás2; Ahol az utasítást jelöltünk, ott tehát blokk is állhat.

Ez esetben az IF szerkezet formája: IF logikai kifejezés THEN BEGIN utasítás1; utasítás2; END ELSE BEGIN utasítás3; utasítás4; END; A feltétel teljesülése esetén az utasítás1 és az utasítás2, ellenkezô esetben pedig az utasítás3 és az utasítás4 kerülnek végrehajtásra. A CASE utasítás A CASE utasítással könnyen megoldhatjuk programunk többirányú elágaztatását. A case utasítás tartalmaz a case kulcsszó után álló szelektort, amelyet az of kulcsszó zár. Ezt követi az úgynevezett case konstans és a hozzá tartozó utasítás vagy utasítások és végül nem kötelező egy else ág. A case utasítást az end zárja Szerkezeti formája: CASE selektor OF cimke1 : utasítás1; . cimken : utasításn; else utasításm; END; FoxPro IF . ENDIF Az IF utasítás kiértékeli az IF ágon megadott logikai feltételt. Ha az igaz, akkor az ott következő utasításokat végrehajtja, majd az ENDIF után következő utasításra lép át. Ha hamis,

akkor az ELSE utáni utasításokat hajtja végre. Ha nincs else ág, akkor ez utóbbi esetben a program az ENDIF utáni utasítással folytatódik. Szerkezeti formája: IF feltétel utasítások ELSE utasítások ENDIF DO CASE . ENDCASE A DOCASE . ENDCASE szerkezettel többszörös elágazási lehetőséget vizsgálhatunk meg. A program sorban ellenőrzi a CASE utáni feltételeket. Ha a CASE ágakon megadott feltételek egyike sem teljesül, akkor az OTHERWISE ágon megadott utasításokat hajtja végre. Ha nem adunk meg OTHERWISE ágat, akkor a ENDCASE utáni első utasítás végrehajtása következik. Szerkezeti formája: DO CASE CASE feltétel1 utasítások [CASE feltétel2] utasítások [OTHERWISE] utasítások END [CASE] 19. A2 tétel Sorolja fel a file-típusokat Turbo PASCAL-ban. Ismertesse a típusos file-kezelést és alkalmazásának sajátosságait Turbo PASCAL-ban. A Turbo PASCAL -ban ismerünk szöveges file-okat, típusos állományokat és típus nélküli

állományokat. Típusos állomány: File of alaptípus; A típusos file -ok olyan adathalmazok, amelyek jól definiált, azonos típusú összetevőkre, elemekre bonthatók. Az elemek típusa a file és objektum típus kivételével tetszőleges lehet. A file-ban tárolt elemek a felírás sorrendjében 0 -tól kezdve egyesével sorszámozódnak. A file feldolgozásánál ezen sorszám felhasználásával pozícionálhatunk az állomány valamely elemére. A file-kezeléses szóhasználatban általában a rekord szót használják a file elemeire. A Pascal nyelvben a rekord szó azonba n a felhasználói adattípust (record) jelöli. Művelet Deklaráció Irás/olvasás jellege Összerendelés Nyitási módok Írás Olvasás Pozicionálás Pozíció- és fileméret Típusos Var f:file of típus; egy komponens írható vagy olvasható (alaptípus) Assign(f,filenév) Reset: irás/olvasás Rewrite: írásra/olvasásra újra létrehoz Write(f,komponensek) Read(f,komponens) Seek(f,n)

Filepos(f): longint; Sizeof(f,komponens); Filesize(f); 20. A2 tétel Statikus és dinamikus változók a Turbo Pascal-ban. Memóriakezelés A mutató típus fogalma, használata (a halom (HEAP) szerepe, használata) Változók: A számítástechnika egyik alapegysége, amely meghatározott értékekből bármelyiket felveheti, azaz egy halmaz elemei közül egyet és csak egyet. A halmaz tulajdonságai határozzák meg a változó típusát. A változó tárterülete az aktuális értéket tartalmazza. Statikus változók: A térbeli helyfoglalást a fordítóprogram jelöli ki (kivétel: abszolút változók),minden esetben deklarálni kell. Dinamikus változók: A változó helyet a programozó jelöli ki, amely megváltozhat a program futása közben. A deklarációs részben nem jelenik meg. Ezért hoztak létre a mutató típust A mutató tartalma a memória egy címe amely kijelöli a dinamikus változó kezdőcímet. Ez több típust foglal magába. Aszerint, hogy milyen

kezdőcímet jelöl, a mutató típusa különböző lehet. NEW(mutató); Dispose(mutató); Eljárás. Megszünteti a mutatóhoz hozzárendelt dinamikus változót és felszabadítja az általa lefoglalt területet. A NEW parancs előtt nem lehet meghívni. Mark(mutató); Hatására a mutató felveszi a szabad HEAP terület kezdetét jelző mutató értékét. Release(mutató); Az összes olyan dinamikus változót megszünteti, amely az utolsó kijelölési pont után van. Getmem(mutató, h:word); A változónak helyet foglal a HEAP-ben, de a programozó adja meg, hogy mennyi legyen ez a hely. Freemem(mutató, h:word); Egy teljes blokkot szabadít fel a HEAP-ben. Memavail:longint; A függvény értéke a HEAP-ben létező szabad hely nagysága byteban. Maxavail:longint; A legnagyobb szabad blokk nagysága a HEAP-ben, byte-ban mérve. Addr(v):pointer; A függvény értéke a paraméterként szereplő változó, függvény ill. eljárás címe Cseg:word; A függvény értéke a

kódszegmens kezdőcíme. Dseg:word; A függvény értéke az adatszegmens kezdőcíme. Sseg:word; A függvény értéke a stackszegmens kezdőcíme.(a veremmutató legkisebb értéket adja vissza). Sptr:word; A stack pointer az aktuális szegmenscímet adja vissza. Seg(v):word; A függvény értéke v szegmenscíme lesz. Ofs(v):word; A függvény értéke v offsetcíme lesz. Az operatív memória minden byte-ját megszámozhatjuk, e sorszámot értjük az adott byte címen. E sorszám byte -onként eggyel emelke dik. Egy változó címe: a változó első byte-jának a címe. A cím szerepe(többek között):segítségével egy változó a tárban elérhető, helye megváltoztatható. A memória egy címét két hexadecimális konstanssal adhatjuk meg. Az első a memória egy abszolút címe, egy alapcím, más néven szegmenscím. A második pedig egy ehhez viszonyított, byte -ban mért távolság, amit offsetnek nevezünk.(Az alapcím ténylegesen egy szegmens kezdőcíme.) A

szegmens a memóriakezelés egyik alapfogalma. A memóriában elhelyezkedő program részei a memória egy-egy partícióját foglalják el, ezeket szegmenseknek nevezzük. A szegmensekre való felosztás: 1. Az a terület, amely a betöltött programot tartalmazza, a kódszegmens Ennek mérete a 4.0 verzióig (a unitok megjelenéséig) max64 Kbyte volt Ma azonban már csak az operációs rendszer szab felső határokat. A DOS operációs rendszer használata mellett a teljes használható operatív memória 640 Kbyte, beleértve ebbe a rezidens és egyéb betöltött programokat valamint adatterületüket is . (Az abszolút címek kezelését segíti elő a CSEG, DSEG és SSEG standard függvény. Értékük a kód -, adat -, és a stackszegmens kezdőcíme. Ezek a függvények word típusúak) A változók szegmens és offset címét két standard függvény adja meg. Bemenő paraméterük egy bármilyen típusú változó, sőt annak része(Pl.tömb eleme, record mezője). 2. Az

adatszegmens szolgál a program adatainak a tarolására Ezt segíti a stackszegmens is amely a dinamikus memóriakezelés fő területe. A betöltött program adatai - fajtájuktól függően- a kód, a stack - és az adatszegmensben helyezkednek el. E változók statikusak, mivel a program futása során a memóriának azonos részén helyezkednek el. Más szempontból ezek a változók globálisak, mivel a teljes program területén használhatjuk őket. A szubrutinok változói csak a szubrutin működése alatt "élnek”. Ezek tehát lokális változók A dinamikus változók általában a stackszegmensbe kerülnek, de lehetőség van arra, hogy más szegmens területére áthelyezzük őket. Az abszolút változókat is bármely szegmensben elhelyezhetjük. SZEGMENS: A memóriában elhelyezkedô program részei a memória egy-egy partícióját foglalják el, ezek a szegmensek. KÓDSZEGMENS: Az a terület amely, a betöltött programot tartalmazza. ADATSZEGMENS: A program

adatainak(statikusak, globálisak) tárolására szolgál. STACKSZEGMENS: A localis, dinamikus változók tárolására szolgál. OFFSET: Eltolás, a szegmenscímhez viszonyított, byte-ban mért távolsága A Turbo - Pascal memória felosztása: +-----------------------------+ ¦ SZABAD LISTA ¦ +-----------------------------¦ ¦ SZABAD MEMORIA ¦ +-----------------------------¦ ¦ HEAP ¦ +-----------------------------¦ ¦ OVERLAY BUFFER ¦ +-----------------------------¦ ¦ STACK ¦ +-----------------------------¦ ¦ STACK SZABAD TERÜLETE ¦ +-----------------------------¦ ¦ GLOBÁLIS VÁLTOZÓK ¦ +-----------------------------¦-----------+ ¦ TIPIZÁLT KONSTANSOK ¦ .EXE file ¦ +-----------------------------¦tartalma ¦ ¦ SYSTEM UNIT ¦ ¦ +-----------------------------¦ ¦ ¦ FÖPROGRAM KÓDSZEGMENSE ¦ ¦ +-----------------------------¦-----------+ ¦ PSF ¦ +-----------------------------+ PSF: EXE file fejlécét tartalmazza. SYSTEM UNIT: Általános célú

standard függvényeket, eljárásokat tartalmaz (mindig hozzászerkesztôdik a programhoz.) OVERLAY BUFFER: Az átlapolás területe. STACK: Verem típusú adatszerkezet, ezen keresztül történik a paraméterátadás függvények és eljárások hívásakor. A stack visszafelé növekszik HEAP: Verem típusú adatszerkezet (LIFO típusú), pointeres változók használatára. 21. A2 Az overlay programozás fogalma, szerepe és lehetőségei és indoka a Turbo PASCAL-ban. A $O kapcsoló és paraméteres direktívák használata. A DOS alatt futtatott programok méretének az operációs rendszer felső korlátot állít. E határérték 640 Kbyte, azaz a program kód - és adatterületeinek együttes hossza nem lehet ennél nagyobb. Ezt a korlátozást oldhatjuk fel az átlagolásos technika alkalmazásával. Az így készült programokat nem kell teljes egészében betölteni a memóriába, elegendő annak csak egy részét. Ha a vezérlés olyan részre kerül, amely nincs a

memóriában, akkor az először betöltődik, s csak akkor folytatódik rajta a vezérlés. Így tehát a program említett tagjai egymást váltják a memóriában. Ezeket átlapolt részeknek nevezzük, a bemutatott mechanizmust átlapolásnak, a memória azon területét pedig, amelyen az átlapolás történik, overlay buffer-nek. Ez utóbbi az 5.0 verziótól a stack szegmens területén, a stack és a heap között helyezkedik el. Az ove rlay buffer nagysága megegyezik a legnagyobb átlapolt rész nagyságával. Az 50 verziótól kezdve az EXE kiterjesztésű, lefordított programokhoz tartozó átlapolt partíciók összessége a programmal azonos nevű, OVR kiterjesztésű file-ban foglal helyet. A vezérlés az ebben lévő eljárások egy-egy csoportját időnként betölti az overlay bufferbe. Az overlay terület nagysága akkora, hogy az overlay csoportok közül a még a legnagyobb is beleférjen, a többi mellett pedig marad redundáns hely is a memóriában. A Turbo

rendszer által lefordított programok automatikusan kezelik az overlay struktúrát. Ha a főprogramban valamely átlapolt eljárásra hivatkozunk, akkor a lefordított program először megvizsgálja, hogy az eljárás benn van-e az overlay bufferben. Ha igen, akkor egyszerűen az említett szubrutinon folytatód ik a vezérlés. Ha nincs az overlay bufferben, akkor betöltésre kerül a hívott eljárás. Az egy ovelay területhez tartozó eljárások összességét egy overlay csoportnak nevezzük. Minden overlay csoportot külön unit-ban helyezünk el. Az átlapolási technika jelentős tármegtakarítást eredményezhet. Hátránya, hogy az overlay hozzáfordulások sokszor háttértárhoz fordulást is jelent egyúttal. A háttértárkezelés megnöveli a gépidő felhasználást, ezért arra kell törekednünk, hogy minél kevesebbet lapozzunk az overlay e ljárások között. Ugyanannak az overlay eljárásnak a többszöri meghívása nem jár háttértár művelettel - s

így plusz gépidő-felhasználással - ,mivel az egyszer betöltött eljárásokat újrahívásuk esetén a program nem tölti be még egyszer. Az O fordító direktíva Az átlapolandó eljárásokat külön unit-okban helyezzük el, ezeket overlay típusú unit -oknak nevezzük. Egy ilyen unit -ban azokat az eljárásokat helyezzük el, amelyek egyszerre lesznek az overlay bufferben. A unitok overlay jellegét az O fordító direktíva bekapcsolásával jelöljük A főprogramban is bekapcsoljuk a direktívát; ezzel jelezzük a fordítónak, hogy átlapolt szubrutinok is lesznek a programban. Hasonlóképpen be kell kapcsolnunk az F direktívát is. Ezzel az eljárások és függvények meghívásának módját állíthatjuk be. A főprogramban fel kell tüntetnünk, milyen overlay típusú unit-okat akarunk használni. Ezt szintén az O direktívával érhetjük el, a következő módon:{$O unitn‚v}.Ezt a uses deklarációk után alkalmazzuk Fordító direktívák A

direktíva: adatok igazítása - Ha a direktíva aktív, akkor a deklarált változók és tipizált konstansok szóhatárra kerülnek a memóriába. B direktíva: logikai kifejezés-kiértékelés - Ha a direktíva aktív, akkor a logikai kifejezések teljes mértékben kiértékelésre kerülnek. D direktíva: nyomkövetés - Aktív állapotban un. debug információt, másnéven nyomkövetést ad, azaz a fordító egy táblázatban a forrásprogram minden sorához feltünteti, hogy lefordítva mely címen kezdődik a generált gépi kódban. E direktíva: emuláció - Aktív állapotában a numerikus co-processzor emulálásra kerül. F direktíva: távoli hívás generálása - A direktíva működéséhez két fogalom - a közeli és a távoli hívások, azaz a NEAR, ill. FAR hívási módok - ismerete szükséges. Az eljárások és függvények hívásakor a visszatérési cím a stack -ben kerül tárolásra. E címtől kezdve folytatja a program a működését a szubrutin

végrehajtása után. Ez a modul hívása utáni utasítás címét jelenti. A közeli hívások tulajdonsága, hogy 16 bites, azaz egy szó hosszúságú visszatérési címet raknak le a stack -ben. Ez csak az offset-et tartalmazza, tehát az adott szegmens alapcíméhez képest relatív címet. A távoli hívások 32 bites, azaz dupla szavas visszatérési címet raktároznak a stack -ben, amely tartalmazza a szegmens alapcímét és offsetjét. I direktíva: I/O ellenőrzés, beszúrt file-ok