Turbo Pascal Tetelek

Forrás: http://www.doksi.
hu
1. A.1. 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.
Forrás: http://www.doksi.hu
1. A.2. 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. A.1. 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.,
Feltétel
i\ /n tesztelő doboz
utasítás
ciklusmag
ut. ut. értékadó utasítás
utasítás
Blokkdiagramm:
1., 2., 3.,

i n
utasítás felt.
utasítás utasítás utasítás

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 ...

utasítások
legyen ...
3., Ciklus eleje Ciklus eleje

tedd addig amíg (feltétel) tedd
utasitás utasítás
utasítás utasítás
Ciklus vége. tedd addig amíg
Ciklus vége.
2. A.2 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íte-
nü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.
<hasonlító kifejezés>
\ é1 : \ é2 : \ é3 : \ else
FoxPro-ban DO CASE ... CASE... END CASE szerkezet ábrázolása.
\ \ \ \ Otherwise
<feltétel1> <feltétel2> <feltétel3>
- hátultesztelô doboz : Repeat ... Until <feltétel> hátultesztelô

ciklusszerkezet ábrázolása.
PASCAL-ban
<ciklusfeltétel>
- minôsítô doboz : With <hatáskör> Do minôsítô utasítás szerkezet ábrázolása.

PASCAL-ban
<hatáskör>
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 Clipboardon
keresztül vihetô be
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 <memv.né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. A.1 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 é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.
Tipusértékhalmaz : egy adat lehetséges értékeinek halmaza.
Elemi típus:
bit
típusérték halmaza {0,1}
mûveletek halmaza {or, and, not, xor, <, >, =}
Adattípusok a Turbo Pascalban:
1.Egyszerû típusok értékek
- Egészek:
Byte 0..255
Word 0..65,535
ShortInt -128..127
Integer -32,768..32,767
Longint -2,147,483,648..2,147,483,647
- Logikai:
Boolean True,False
- Karakter:
Char bármely ASCII karakter Pl: 'A'
- Felsorolt: a felsorolásban szereplô elemek Pl
T=(ôsz,tél)
- Intervallum: a már létezô sorszámozott típus egy
intervalluma
Pl: T = 1..100
- Valós:
Real 2.9E-39..1.7E38
Single 1.5E45..3.4E38
Double 5.0E-324..1.7E308
Extended 3.4E-4932..1.1E4932
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 : Egészek
B : String
Elegy = Record
Szám: A
Név : B
End;
2.Alternatív (unió) típus:

Adott 2 halmaz amelybe 1-1 típusnak megfelelô elemek vannak, e két hal-
maz 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,2..10] of Integer; 2 dimenziós, egész számokból
álló mátrix.
3. A.2. 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. A.1. 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 blokkdiagram, a szöveges leírás és a

stuktogram.
Szekvenciának nevezzük a sorban egymás után való utasít ások

végrehajtását.
Pl.:
Elágazásnak nevezzük azt, ha egy algoritmus során elágazunk, de

továbbra is előre megyünk.
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. A.2 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 értékek

- Egészek:
Byte 0..255
Word 0..65,535
ShortInt -128..127
Integer -32,768..32,767
Longint -2,147,483,648..2,147,483,647
- Logikai:
Boolean True, False
- Karakter:
Char bármely ASCII karakter Pl: 'A'
- Felsorolt: a felsorolásban szereplő elemek
Pl: T=(öszérték)
- Intervallum: a már létező sorszámozott típus egy
intervalluma
Pl: T = 1..100
- Valós:
Real 2.9E-39..1.7E38
Single 1.5E45..3.4E38
Double 5.0E-324..1.7E308
Extended 3.4E-4932..1.1E4932
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[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],[2..10] 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. A.1. 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. A.2. 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
{ inicializációs rész }
END.
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
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
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 kezdődik, ezután

következik a függvény azonosítója (a neve), a formális
paraméterlistája és a függvény típusa.
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. A.1. 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 d
elemet és onnan vehetünk ki
elemet. Amit legutoljára c
tettünk be, azt kell kivenni
először. Ez angolul Last In b
First Out (LIFO). A vele
végezhető műveletek: a verem a
tetejére való ráhelyezés és a
verem tetejéről való levétel.
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 speciális mutató
0 1 Adat 2 Adat 3 Adat 4
A mutatókat külön vektorban helyezzük el. Cikluslistának vagy

gyűrűnek nevezzük, amikor a lista végét visszaláncoljuk a
listafejhez.
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 Fizetés
Név Fizetés
Név 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 ozva a
sorrendje. Műveletei az ismert halmazműveletek.
6. A.2. 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 Típus nélküli
Deklaráció Var f:file;

Irás/olvasás egy komponens 128 byte-os blokkban írható vagy
jellege olvasható
Összerendelés Assign(f,filenév)
Nyitási módok Reset(f,rekordmeret): írás, olvasás
Rewrite(f,rekordmeret): írás, olvasás
újralétrehozás
Írás BlockWrite(f,komp)
Olvasás BlockRead(f,komp)
Pozicionálás Seek(f,n)
Pozíció- és fileméret 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 FŐOSZTÁLYVEZETŐ2 FŐOSZTÁLYVEZETŐ3
OSZTÁLYVEZETŐ1-1 OSZTÁLYVEZETŐ1-2 OSZTÁLYVEZETŐ2-1 OSZTÁLYVEZETŐ2-

2
A1
E1 E2 E3
NIL
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 1
VEVŐ ELADÓ
1 1
M M
M N M N
TELEPHELY MEGRENDELÉS ÁRU SZÁLLITÓ
1 M
1 N
SPECIFIKÁCIÓ 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. A.1. 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. A.2 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 255.elem. Í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 [10..20] 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 [0..31] of Real;
Tomb2:Array [1..10,0..31] 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*3*6= 36 Byte-ot, T3 pedig 2*3*4*2= 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 eljar.prg 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. A.1. 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 a
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.
8. A.2. 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
tömb = array[1..10][1..10] of real;
betuk = set of [a..z];
tfile = file of integer;
komplex = record
x, y: real;
end;
st12 = string[12];
var
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 keresés nem tesz
különbséget kis és nagybetű között.
<kifC1>$ <kifC2>
ALLTRIM()
Egy karakter bevezető és záró szóközének levágása. Visszaadott
értéke egy karakteres kifejezés.
ALLTRIM(<kifC>)
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 értéke egy
karakter, amely az ASCII kódnak felel meg.
CHR(<kifN>)
ISALPHA()
Azt vizsgálja, hogy egy karaktersorozat betűvel kezdődik-e.
Visszaadott értéke igaz (.T.) vagy hamis (.F.).
ISALPHA(<kifC>)
ISDIGIT()
Azt vizsgálja, hogy egy karaktersorozat számmal kezdődik-e.
Visszaadott értéke igaz (.T.) vagy hamis (.F.).
ISDIGIT(<kifC>)
LEFT()
A karaktersorozat meghatározott részét adja vissza a bal oldaltól
számítva.
LEFT(<kifC>,<kifN>)
LEN()
A karaktersorozat hosszát adja meg numerikus egészként. Minden
byte-ot 0-nak számol.
LEN(<kifC>)
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é konvertálja. Csak a
betűknél végzi el a műveletet.
LOWER(<kifC>)
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. A.1. 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 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. A.1. 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
Ha A(I) T tulajdonságú akkor J:=J+1 : B(J):=I
Ciklus vége
Eljárás vége.
11. A.2 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. A.1. 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
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
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 megfelelôen a

grafikus üzemmódban a felbontás és színeinek száma (ezek a grafikus kártya
legjellemzôbb adatai) eltérôek .
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 )
TANDY
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 sebessége DOS -ban
90%-kal, Windows-ban 50%-kal nagyobb.
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. A.1. 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 40 3 31 47 22 24 33 7 46
1. menet után: 56 64 8 42 5 12 16 40 3 31 47 22 24 33 7 46
2. menet után: 8 56 64 42 5 12 16 40 3 31 47 22 24 33 7 46
3. menet után: 8 42 56 64 5 12 16 40 3 31 47 22 24 33 7 46
4. menet után: 5 8 42 56 64 12 16 40 3 31 47 22 24 33 7 46
5. menet után: 5 8 12 42 56 64 16 40 3 31 47 22 24 33 7 46
...........
...........
...........
15. menet után: 3 5 7 8 12 16 22 24 31 33 40 42 46 47 56 64
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.
13. A.2 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 -ban
élnek. A program során csak erre az idôre terhelik a memóriát.
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 FoxPro-

ban
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 tömb

deklarálható egyidejűleg egy PRIVATE utasítással.
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. A.1. 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. A.1. 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. A.2. 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. A.2 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. A.1. 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. A.2. tétel

text file-ok alkalmazásának sajátosságait Turbo PASCAL-ban.

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 Text
Deklaráció Var f:text;
Irás/olvasás egy sor (CL/LF)
jellege csak írható vagy csak olvasható,
szekvenciális
Nyitási módok 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
Í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
Olvasás Read(f,sor) nem emel sort
Readln(f,sor) emel sort
Pozicionálás -
Pozíció- és fileméret 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.
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.
DO CASE
CASE feltétel1
utasítások
[CASE feltétel2]
utasítások
[OTHERWISE]
utasítások
END [CASE]
19. A.2. tétel

típusos file-kezelést és alkalmazásának sajátosságait
Turbo PASCAL-ban.

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 Típusos
Deklaráció Var f:file of típus;
Irás/olvasás egy komponens írható vagy olvasható (alaptípus)
jellege
Nyitási módok Reset: irás/olvasás
Rewrite: írásra/olvasásra újra létrehoz
Írás Write(f,komponensek)
Olvasás Read(f,komponens)
Pozicionálás Seek(f,n)
Pozíció- és fileméret Filepos(f): longint;
Sizeof(f,komponens);
Filesize(f);
20. A.2 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 byte-
ban.
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) max.64 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. A.2.
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 5.0 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 unit-
ok 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.

Turbo Pascal Tetelek

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Turbo Pascal Tetelek

Uploaded by

Copyright:

Available Formats

Forrás: http://www.doksi.

Elemi programozási tételek III.: a lineáris keresés és a

Általános feladat: Rendelkezésre áll egy N elemű sorozat, egy, a

Általános feladat: adott egy rendezett N elemű sorozat és egy

A strukturált programozás jellemzői. A modul fogalma, és

Egy programot akkor nevezünk strukturáltnak, ha nem tartalmaz

A Pascal program három fő részből áll:

A Pascal program szerkezete:

procedure eljárásnév (paraméterek);

function függvénynév (paraméterek);

Adatállomány kezelése: létrehozás, megnyitás, módosítás

CREATE: Új adatbázis létrehozása.

CREATE TABLE: Adatbázis létrehozása megadott mezőkkel.

CREATE TABLE | DBF <dbf -név> (<mezőnév1> <típus> [(<hossz>

USE: Egy adatbázis és kapcsolóállományai megnyitása.

USE [<adatbázisnév|?>][IN <munkaterület>] [AGAIN] [INDEX

MODIFY STRUCTURE: Adatbázis struktúrájának módosítása.

Algoritmus fogalma, tulajdonságai, felépítése,

Az algoritmus fogalma: Az algoritmus több, esetleg végtelen sok

a., Meg kell adni a végrehajtandó műveleteket, azaz le kell írni,

a., Az algoritmust a végrehajtó számára szóló utasításokból építjük

Az algoritmus leíró eszközei

1., Szekvencia: sorban egymás után való végrehajtás.

1., 2., 3.,

utasítás utasítás utasítás

2., legyen ...

3., Ciklus eleje Ciklus eleje

Struktúrák ábrázolása a Turbo PASCAL-ban és a FoxPro-ban

Az egyszerû és összetett programstruktúrák, és maga a teljes struktúrált program

Programnyelvôl nem függô struktogramok

- adatátalakító, vagy döntési doboz : egyszerû struktúrák, másnéven szekvenciák

- kétirányú elágazásos tesztelô doboz : az IF kulcsszóval kezdôdô feltételes

- elôltesztelô doboz : elôltesztlô For, illetve While Do ( DO WHILE ) ciklusok

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.

FoxPro-ban DO CASE ... CASE... END CASE szerkezet ábrázolása.

- hátultesztelô doboz : Repeat ... Until <feltétel> hátultesztelô

- minôsítô doboz : With <hatáskör> Do minôsítô utasítás szerkezet ábrázolása.

Adattipusok FoxPro 2.5-ben. Típuskonverziók

Numerikus (Numeric), (max. 20 számjegy)

Lebegôpontos numerikus (Float), (max. 20 számjegy)

Dátum (Date),(8 byte)

Logikai (Logical),(1 byte)

Feljegyzés (Memo) (Üresen 10 karakter)

Általános (General) / Grafikus (Picture), (Üresen 10 karakter)

Adatbázis allományon kívül tárolt adatok (konstansok)

Állapottér és típus fogalma

Típus fogalma: Típusnak nevezünk egy adathalmazt és a rajta értelmezett

Adattípusok a Turbo Pascalban:

1.Egyszerû típusok értékek

- Halmaz: Sorszámozott típusú elemek, maximum 256 db.

- Típusos: 4 byte-os memóriacímet tartalmaz

1.Direkt szorzat típus:

Matematikai jelölése : A X B=(a,b)

2.Alternatív (unió) típus:

az egyik típusú elemek közül választunk, vagy a másik típusúak közül,

3.Sorozat (iterált) típus :

Programozásban megvalósítva pl. : tömb Pascalban

Elemi programkonstrukciók a Turbo PASCAL-ban (értékadás,

Alapvető I/O műveletek:

A Pascal programozásban a standard output (szabványos kimenet)

Egész típusú eredmények kiíratása: Write(paraméter : n), vagy

A Turbo PASCAL-ban a standard input (szabványos bemeneti)