5. ADATtípusok és Deklarációk Ebben a fejezetben részletesen tárgyaljuk a változók deklarálását, foglalkozunk a felhasználói típusok létrehozásával, a struktúrált adattípusokkal, valamint a konstansok megadásával. Példákon keresztül mutatjuk be használatukat, a fejezet tartalmának a begyakorlására ajánljuk az ellenőrző kérdések áttanulmányozását. A programok az adatokat változókban tárolják. A változók egy vagy több byte-ot foglalnak le a memóriából, ez a tárterület tartalmazza a változók aktuális értékét. A program futása során a változók változtathatják az értéküket. Ha megvizsgáljuk egy változó tartalmát, akkor pillanatnyi értékről beszélünk. Minden változót el kell neveznünk az azonosítók szabályai szerint, ezek az ún. változóazonosítók. Minden változó a tulajdonságától függően veheti fel értékét. A változó tulajdonságát típusnak nevezzük. A Pascalban a var kulcsszó után minden változót deklarálnunk kell és meg kell jelölnünk a típusát. A deklarációban egy változó csak egy típusnál szerepelhet. Ha egy típushoz több változó tartozik, akkor azokat vesszővel elválaszta kell felsorolni, majd a kettőspont után a típus következik és az utasítást pontosvessző zárja. var a,b : integer; x : real; A Turbo Pascalban vannak beépített adattípusok, de magunk is létrehozhatunk különféle típusokat. A Pascal nyelvben használatos adattípusokat az 5.1. ábra szemlélteti. Az adattípusok tárgyalását az egyszerű adattípusokkal kezdjük. Először ismerkedjünk meg a numerikus értékeket, majd a karaktereket és a logikai értékeket tároló adattípusokkal. 5.1. Egyszerű adattípusok Mint már említettük, az adattípus megmutatja, hogy egy változó milyen értékeket vehet fel, vagyis kijelöli az értékkészletét. Először tekintsük át a nyelvhez tartozó, beépített egyszerű (standard) típusokat. {EMBED MSDraw \* mergeformat|} 5.1. ábra A Pascal nyelv adattípusai 5.1.1. Numerikus információ tárolása Először azokkal az egyszerű adattípusokkal foglalkozunk, amelyek numerikus adatokat, számokat tárolnak. Numerikus adatokat tároló változókkal aritmetikai műveleteket végezhetünk. 5.1.1.1. Egész típusok A Turbo Pascal-ban ötfajta előredefiniált egész típus van: shortint, integer, longint, byte és word. Ezek mind egész számokat tárolnak, de értékkészletük a helyfoglalásuk miatt különböző. Az 5.1. táblázatban összefoglalva tekintsük át az adott típushoz tartozó értékkészletet és a helyfoglalást: típus értékkészlet helyfoglalás ---------------------------------------------------------------------- ---------------------------- shortint -128 .. 127 előjeles 8 bit =1 byte integer -32768 .. 32767 előjeles 16 bit =2 byte longint -2147483648 .. 2147483647 előjeles 32 bit =4 byte byte 0 .. 255 előjel nélküli 8 bit =1 byte word 0 .. 65535 előjel nélküli 16 bit =2 byte 5.1. táblázat A leggyakrabban az integer típust használjuk, természetesen amennyiben a -32768 és 32767 korlát megfelel a számábrázolásra. A programunk tervezésénél gondosan kell megválasztani a változók típusát, mivel nem megfelelő típus esetén a program helytelen eredményt adhat. A Turbo Pascal a legnagyobb lehetséges integer típusú szám tárolására fenntart egy MAXINT konstanst, melynek értéke 32767 és a longint típus számára pedig MAXLONGINT konstanst, melynek értéke 2147483647. A példában különféle egész típusú változók deklarálását láthatjuk: var i,j : shortint; flag : longint; ch : byte; xx : word; n : integer; 5.1.1.2. Valós típusok A Turbo Pascalban a valós számok tárolására 5 különböző típust definiáltak, ezek a real, single, double, extended és a comp. A real használható minden esetben. A másik négyhez 8087 mód használata (8087, 80287 ill. 80387 géptípustól függően) vagy annak emulálása ({$N+}) (szoftver úton való kiváltása) szükséges. A 5.2. táblázat foglalja össze a valós típusokat, a különböző valós típusokhoz tartozó értékkészletet abszolút értékben (ugyanez vonatkozik a negatív számokra, de ellenkező előjellel), az értékes jegyek számát és a helyfogla-lásukat: típus értékkészlet értékes jegyek helyfoglalás ---------------------------------------------------------------------- -------------------- real 2.9x10-39 .. 1.7x1038 11 - 12 6 byte single 1.5x10-45 .. 3.4x1038 7 - 8 4 byte double 5.0x10-324 .. 1.7x10308 15 - 16 8 byte extended 3.4x10-4932.. 1.1x104932 19 - 20 10 byte comp -2-63 +1 .. 263 -1 19 - 20 8 byte 5.2. táblázat A valós típusok közül leggyakran a real típust használjuk. var osszeg, szumma: real; 5.1.2. Logikai információ tárolása A logikai értékek tárolására csak a logikai típusú változók alkalmasak, amelyekkel logikai műveleteket végezhetünk. 5.1.2.1. Logikai típus A boolean kulcsszó után deklaráljuk a logikai típusú változókat, amelyek kétféle értéket vehetnek fel: true (igaz) és false (hamis). A logikai változó helyfoglalása egy byte. var b1,b2 : boolean; 5.1.3. Szöveges információ tárolása Kétféle típus használható szöveges információk tárolására. Tárolhatunk csak egy karaktert, vagy több karaktert, tehát karaktersorozatot. A szöveges információt az ASCII karaktersorozat elemei alkotják. A szöveges információkkal sztring műveleteket végezhetünk. 5.1.3.1. Karakter típus A char a karakter típus egyetlen karakter tárolására alkalmas, amely egy byte-ot foglal le a memóriában. A karakter konstanst aposztrófok közé zárjuk, pl. 'a' , '0', '*'. Az aposztrófok közé zárt 0 a 0 karaktert jelenti, míg a 0 az egész 0 konstanst jelöli. A karakterek az ASCII kódokat tartalmazhatják, amelyek rendezett halmazt alkotnak. A karakterek sorszámozott típusúak. var c1,c2,kod: char; 5.1.3.2. String típus A string típus alkalmas karaktersorozat tárolására. Korábban már említettük, hogy egy karakter egy byte-ot foglal le. A string típusú változó karakte-reinek darabszámára is csak egy byte van fenntartva. A byte-ba írható maximális szám 255, tehát ez szabja meg azt a korlátot, hogy a string típusú változó 255-nél több karaktert nem tartalmazhat. A string nem sorszámozott típus. var nev: string; Ebben a példában a nev maximálisan 255 karaktert tartalmazhat. Ha nem szükséges 255 karakter, használhatunk kevesebbet is, akkor indexben (szögletes zárójelek között) kell megadni a szükséges darabszámot. var keresztnev : string[10]; vezeteknev : string[20]; kod : string[3]; betu : string[1]; A sztringben tárolt karaktersorozat karaktereihez is hozzáférhetünk, használva a sztring-indexet oly módon, hogy a sztring azonosító mellett szögletes zárójelben megadjuk a vizsgálandó karakter sorszámát. A string típusú változók tartalmát karakterenként a sztring-index segítségével könnyen tudjuk vizsgálni. 5.1.4. Sorszámozott típus Az előzőekben megismerkedtünk néhány egyszerű adattípussal. Az 5.1. ábrán láthatjuk, hogy az egyszerű adattípusokat tovább osztályozhatjuk sorszámozott ill. nem sorszámozott típusokra. Sorszámozott típusok amelyekkel már foglalkoztunk: integer, shortint, longint, byte, word, boolean, char Ide tartozik még a felsorolt, résztartomány, amelyeket még nem ismertettünk. Nem sorszámozott típusok pedig a real, string ezeket a típusokat már megismertük. Ismerkedjünk meg most három függvénnyel, amelyek csak a sorszámozott típusok vizsgálatára alkalmasak, ezek: ord, succ, pred Mint már említettük, az ASCII karakterek egy halmazt alkotnak, amelyben mindegyik ASCII karakterhez tartozik egy sorszám és ezért ezen a halmazon könnyen mozoghatunk. Az ord függvény paramétere sorszámozott típus lehet, például karakter típusú változó, karakter konstans, egész szám stb., eredményként a karakter sorszámát vagy a paraméterének típusdeklarációbeli sorszámát adja vissza. A succ függvény bemenő paramétere sorszámozott típus, eredményként a következő elemet adja. A pred függvény bemenő paramétere sorszámozott típus, eredményként az előző elemet adja. A false és a true is sorszámozott. A false sorszáma 0, a true sorszáma 1. Tehát a false < true; Ekkor ord(false) eredménye 0 ord(true) eredménye 1 succ(false) eredménye true pred(true) eredménye false succ('c') eredménye 'd' pred('b') eredménye 'a' succ(7) eredménye 8 pred(10) eredménye 9 5.1.4.1. Felsorolt típus Lehetőség van arra, hogy magunk is létrehozhassunk sorszámozott típusokat. Ezt az ún. felsorolt típust a következőképpen hozzuk létre: a var kulcsszó után megadjuk az azonosítót, majd a kettőspont után kerek zárójelben vesszővel elválasztva soroljuk fel az egyedi azonosítókat. A felsorolás egy nagyság szerinti sorrendet is jelent, ahol az első elem sorszáma 0. Az egyedi azonosítókat nem szabad '' (aposztrófok) közé tenni, mivel ezek nem sztringeket jelentenek. var nyelvek:(angol, nemet, spanyol, olasz); A fenti felsorolt típusokra is nézzük meg az ord, succ és a pred függvény eredményét : ord(angol) értéke 0 ord(spanyol) értéke 2 succ(nemet) értéke spanyol pred(olasz) értéke spanyol. 5.1.4.2. Résztartomány típus Résztartomány típust bármely korábban definiált, sorszámozott típus tetszőleges részsorozatával megadhatunk. A definiálás a részsorozat azonosítójával kezdődik, az a kettőspont egyenlőségjel után a részsorozat, mint intervallum alsó és felső határát kell megadni két ponttal elválasztva, majd pontosvessző zárja az utasítást. var index : 1..100; kisbetu: 'a'..'z'; Az index az egész számoknak, a kisbetu pedig a karakterek sorozatának egy résztartományát jelenti. Az ord függvényt itt is alkalmazhatjuk. Ha futás közben ellenőrizni akarjuk, hogy nem léptük-e át a résztartomány határát, akkor a programot a {$R+} fordító direktívával kell fordítani, mert alapértelmezésben ez a direktíva nem aktív. Ezt csak akkor ajánlatos használni, míg a program helyes működését ellenőrizzük, mert ez a vizsgálat lassítja a program futását. 5.1.5. Mutató típus A mutató típus szintén elemi adattípus. A mutató típust a pointer a kulcsszavával, másrészt pedig ^típus alakban adhatunk meg. A mutató típus memória címet vesz fel, helyfoglalása 4 byte. Az első két byte az offszetcímet, a második két byte a szegmenscímet tartalmazza. Deklarációja a következő: var mem, hely : pointer; iptr : ^integer; 5.2. Struktúrált típusok A struktúrált (másképpen összetett) típusok a tömb, a rekord, a halmaz és a file adattípusok. 5.2.1. Tömb típus A tömb meghatározott számú, azonos típusú elemből álló összetett adattípus. A tömb memóriabeli helyfoglalását az elemszám és az elem típusának megfelelő elemméret szorzatával számíthatjuk ki. Tíz elemű integer (2 byte) típusú tömb 10x2 azaz 20 byte-ot foglal le a memóriában. A tömb megadásának a szintaxisa a tömb azonosítójával kezdődik, majd a : következik, azután az array kulcsszót követő szögletes zárójelben a tömb alsó és felső indexhatárát, mint résztartományt adjuk meg. Az ezt követő of kulcsszó utáni adattípus fogja meghatározni, hogy a tömb elemei milyen adatokat fognak tartalmazni. A típus lehet elemi típus, összetett sőt felhasználó által definiált típus is. var y: array[1..10] of integer; Az y tömb 10 darab egész típusú elemet tartalmaz. A tömb egyes elemeire tömbváltozó nevével és a deklarált határok közé eső indexszel hivatkozunk: y[1], y[2],y[3] .. y[10] Az index lehet sorszámozott típusú változó, konstans vagy kifejezés: i:=2; j:=3; az i változó értéke 2, a j változóé 3, akkor y[i] az y tömb második elemét jelenti, mert i tartalma 2 y[i+j] mivel i+j értéke 5, az y tömb ötödik elemét jelenti y[4] az y tömb 4. elemét jelenti. A tömb ha egydimenziós, akkor vektornak, ha kétdimenziós, mátrixnak nevezzük. Deklaráljuk egy valós számokat tartalmazó mátrixot: var x: array[1..2,1..3] of real; Az x kétdimenziós tömbnek 2 sora és 3 oszlopa van: {EMBED Equation |} A kétdimenziós tömb első indexe a sor index, a második indexe az oszlop index. A második sor harmadik oszlopának elemét a következőképpen választjuk ki: x[2,3] vagy j:=2; k:=2; akkor az x[j,k+1] ugyancsak az x[2,3] elemet választja ki. A tömbök elemei a memóriában az indexük alapján helyezkednek el olymódon, hogy az indexük jobbról balra növekednek. Kétdimenziós tömb esetén először az oszlop index, majd a sor index növekszik (sorfolytonos tárolás). A példában deklarált x vektornál x[1,1], x[1,2], x[1,3], x[2,1], x[2,2], x[2,3] a memóriabeli sorrend. Nézzünk meg egy háromdimenziós deklarációt: var y: array[1..2,1..2,1..3] of real; Az y tömb memóriabeli sorrendje y[1,1,1], y[1,1,2], y[1,1,3], y[1,2,1], y[1,2,2], y[1,2,3], y[2,1,1], y[2,1,2], y[2,1,3], y[2,2,1], y[2,2,2], y[2,2,3]. A Turbo Pascalban a tömb dimenzionálásának egyetlen korlátja az, hogy bármely Pascal adat maximális mérete kisebb kell legyen 64 Kbyte-nál. Az indexhatár 0 és negatív is lehet. Az indexeknek az érvényes számok tartományába kell esniük. Az index alúl- illetve túlcsordulásának figyelésére az {$R+} fordítási direktíva szolgál, az alapértelmezés szerint ez a direktíva nem aktív. 5.2.2. Rekord típus A rekord a legrugalmasabb Pascal adatszerkezet, mivel benne tetszőleges számú különböző tulajdonságú (típusú) rész szerepelhet. A rekord típusdeklarációjában record kulcsszó után fel kell sorolni komponenseinek típusát és ezt a felsorolást end kulcsszóval kell lezárni. Ezeket a komponenseket a rekord mezőinek nevezzük. A következőképpen írhatunk le egy dátumot: var datum : record ev : 1000..2000; honap: 1..12; nap : 1..31; megjegyzes: string; end; A datum rekordnak 4 mezeje van. Az ev, a honap és a nap résztartomány típusú, az adatokat csak a megadott határok között fogadja el. A dátumhoz megjegyzést fűzhetünk a megjegyzes mezőben, amely string típusú. A rekord elemeire úgy hivatkozunk, hogy a rekord változó neve után ponttal elválasztva írjuk az elem azonosítóját. Adjunk értéket a datum rekordnak: datum.ev := 1974; datum.honap := 3; datum.nap := 13. datum.megjegyzes := 'Zoli szuletesnapja'; A variálható rekordnak nevezzük az a rekordot, amelynek mezőadataihoz valamilyen tulajdonságtól függően más és más adatok tartoznak. Példaként nézzük meg, hogy egy könyvtárban a könyveket milyen adatok megadása mellett tarthatjuk nyilván. A könyveknek egy vagy több szerzője lehet. A könyv címe mellett tárolhatjuk a kiadójának nevét, a kiadás évét, az oldalak számát és a leltáriszámot. A könyv tulajdonságát határozza meg az a tény, hogy kölcsönözhető-e. A könyv csak akkor kölcsönözhető, ha a raktárban van. Ilyen esetben a raktárban való helyét tartjuk nyilván. Ha a könyvet kikölcsönözték, akkor a kikölcsönző személy adatait rendeljük a könyv adataihoz. (A case utasítást lásd a 8.2.2.2. részfejezetben.) var konyv : record szerzok : string; cim : string[50]; kiado : string[30]; ev : integer; oldalak : 1..1000; raktariszam: 1..10000; case kiveheto : boolean of true: (hely : record emelet : 1..4; sor : 1..15; polc : 1..50; end); false: ( olvaso : record nev : string[30]; lakcim : string[40]; telefon : string[15]; lejar : string; end); end; 5.2.3. Halmaz típus A halmazelmélet a matematika külön tudományága, bizonyos feladatok leg-természetesebben halmazok használatával oldhatók meg. Ennek támogatására szolgál a Pascal set (halmaz) típusa. A halmaz deklarálása: var halmaz_változó : set of alaptipus; formában történik. A Turbo Pascalban a halmaz maximum 256 elemet tartalmazhat, az alaptípus csak felsorolt (sorszámozott) típusú lehet. var abc : set of 'a'..'z'; szamok : set of 0..1000; a fenti deklarációkat használva az abc halmaz felveheti az alábbi értékeket abc:=[ ]; üres halmaz abc:=['a'..'z']; teljes halmaz abc:=['b','d']; a b és a d betűt tartalmazza A halmazokkal külön részfejezetben újra foglalkozunk. 5.2.4. File típus A file azonos típusú komponensekből álló adatszerkezet, amely nagymeny-nyiségű adat tárolását teszi lehetővé a háttértárolón. A file komponensei lehetnek egyszerű és struktúrált típusok, de leggyakrabban a record típust használjuk. A file változó deklarálása: var adat: file of integer; A file kezeléssel részletesen a 11. fejezet foglalkozunk. 5.3. Felhasználói típus létrehozása (type) Az előbbi részfejezetekben láttuk, hogy minden változónak a deklarációban meg kellett nevezni a típusát. A Turbo Pascal a típusdefiníciós részben a type kulcsszó után saját típusok létrehozását is támogatja. A típusdeklarációt a következő módon kell megadni: type újtipus = létezőtípus; Először a létrehozandó új típus nevét, illetve azonosítóját adjuk meg, majd az = (egyenlőségjel) után különféle létező típust, akár korábban definiált saját típust is meg lehet adni. type egesz = integer; valos = real; st10 = string[10]; var i,j : egesz; a,b : valos; nev : st10; A későbbiekben inkább a strukturált típusokra fogjuk alkalmazni típus- alkotást, mivel az eljárások és függvények a struktúrált típusokat paramé-terként csak ily módon fogadják el. 5.3.1. A type használata felsorolt típus esetén A felsorolt típus megadása és ezen típusoknak a deklarációban való felhasználása az alábbiak szerint történik: type tantargy=(magyar, fizika, matematika,tortenelem); nyelvek =(angol, nemet, spanyol, olasz, kinai); szinek =(piros,kek,zold,sarga,lila,fekete,feher); var orarend : tantargy; nyelvora: nyelvek; ruha : szinek; A fenti felsorolt típusokra is használhatjuk az ord, succ és a pred függvényeket. Más szabványos függvény használata ezeknél a típusoknál nem megengedett. Ugyanakkor az a szabály is teljesen egyértelmű, hogy az angol, nemet, spanyol és az olasz értékeket csak nyelvek típusú változó veheti fel, mint például a deklarációban látható nyelvora. 5.3.2. A type használata résztartomány típus esetén Résztartomány típust valamely létező, sorszámozott típus bármely rész- intervallumából állíthatjuk elő. A definiálás a résztartomány típus azonosítójával kezdődik. Az egyenlőségjel után az intervallum alsó és felső határát kell megadni két ponttal elválasztva, majd pontosvessző zárja az utasítást. type szinek =(piros,kek,zold,sarga,lila,fekete,feher); kisbetu = 'a'..'z'; szam = '0'..'9'; szinresz = kek..lila; korlat = 10..100; index = 1..1000; var minta: szinek; i,j : index; alap : szinresz; A szinresz típus változó a résztartományát a korábban definiált felsorolt típusú szinek alapján jelöljük ki. Œgy az alap csak a kek, zold, sarga ,lila színeket veheti fel értékként. 5.3.3. A type használata tömb esetén Ha a tömböt felhasználói típusként akarjuk deklarálni, akkor a felhasználói típusú tömböt először a type kulcsszó mellett a változó deklarációhoz hasonlóan adjuk meg, csak a : helyett = jelet kell tennünk és ezután már a var kulcsszó után használható a kívánt deklaráció. Nézzük meg az alábbi tömbtípusok deklarációban való felhasználását: type szinek =(piros, kek, sarga, feher); nev = string[20]; vektor = array[1..100] of real; matrix = array[1..10,1..10] of integer; adat = array[1..50] of real; osztaly = array[1..32] of nev; szintabla = array[1..8,1..8] of szinek; abc = array['a'..'z'] of char; xx = array[-1..4, 0..2] of integer; var a,b : vektor; x,y : matrix; w : szintabla; konyv : abc; tarol : xx; 5.3.4. A type használata record esetén Nézzünk példát rekordtípus létrehozására: type datum = record ev : integer; honap: (jan,febr,marc,apr,maj jun,jul, aug,szept,okt,nov,dec); nap : 1..31; megjegyzes: string; end; szemely= record vezetek_nev: string[20]; kereszt_nev: string[10]; szul_datum : datum; allapota : (hajadon,notlen,ferjezett, nos,ozvegy); lakcim : string; end; var mai_nap, holnap: datum; munka_csoport : szemely; 5.3.5. A type használata halmaz esetén A halmaztípus deklarálása: type halmaz_tipus = set of alaptipus; formában történik. Például: type napok = (hetfo,kedd,szerda,csutortok, pentek,szombat,vasarnap); het = set of napok; var munkanap, pihenonap,teljes_het : het; 5.4. Konstansok deklarálása A konstansok deklarációja a const kulcsszó után történik úgy, hogy az egyenlőségjel bal oldalán megadjuk az azonosítót, a jobb oldalán pedig a hozzárendelni kívánt értéket. A fordítóprogram az azonosító típusát a jobb oldalon álló konstansból állapítja meg. Numerikus konstansok: const jelzo = -1; ev = 1991; norm = 25.6; max = 1.5e6; min = 1e-5; hexa = $00ff; Szöveges konstansok: const fejlec ='Az egyenlet megoldasa'; cim1 ='Feladat:'; betu ='w'; ures_sztring =''; A konstansok annyiszor szerepelnek a programban, ahányszor használjuk azokat. Ezzel szemben a tipusos konstansok csak egyszer jelennek meg a lefordított programban. 5.4.1. Típusos konstansok Típusos konstansok megadási módja: típusos konstans azonosítója kettős-ponttal zárva, majd a típus azonosítója következik és az egyenlőségjel után az értéket kell megadni, végül az utasítást pontosvessző zárja. A típusos konstansok paraméterként használhatók, azonban nem használhatók más konstansok és típusok deklarációjában. A típusos konstansok nemcsak egyszerű típusúak lehetnek, hanem összetett típusúak, így tömb, halmaz és rekord típusú is. A típusos konstans nem lehet file típusú. Mutató lehet pl.: const xp: pointer = pointer($FFFFFFFF); Tömb típusú típusos konstans Egydimenziós tömb esetén az értékeket zárójelek között vesszővel kell felsorolni. const adatok: array[1..4] of integer =(5,1,3,7); fejlec1:array[1..8] of char =('M','e','g','o','l','d','a','s'); fejlec2: array[1..8] of char = ('Megoldas'); Példaként nézzük meg az alábbi 3 dimenziós deklarációt és értékadást: var a: array[1..2, 1..2, 1..3] of integer; begin a[1,1,1]:=1; a[1,1,2]:=2; a[1,1,3]:=3; a[1,2,1]:=4; a[1,2,2]:=5; a[1,2,3]:=6; a[2,1,1]:=7; a[2,1,2]:=8; a[2,1,3]:=9; a[2,2,1]:=10; a[2,2,2]:=11; a[2,2,3]:=12; Ha többdimenziós konstansként adnánk meg az előző feladatot, akkor az értékeket a tömböknél a dimenziónak jobbról balra növekvő sorrendjének megfelelően kell megadni. const a:array[1..2, 1..2, 1..3] of integer= (((1,2,3),(4,5,6)),((7,8,9),(10,11,12))); Többdimenziós konstansok értékadását mutatja be a TOMB_IND.PAS program. Halmaz típusú típusos konstans A halmaz elemeit résztartományként, vagy az elemek felsorolásával lehet megadni: const Szam10 : set of char = ['0'..'9']; ABC : set of char = ['a'..'z','A'..'Z']; Mgh : set of char = ['a','e','i','o','u']; Rekord típusú tipusos konstans Először a rekord típusát hozzuk létre, majd a const után a rekord konstanst úgy adjuk meg, hogy a mezőkonstansok a típusdefiníció sorrendjében kapjanak értéket. Például dátum esetén: type datum = record ev : integer; honap : 1..12; nap : 1..31; megjegyzes: string; end; const mai_nap : datum = (ev: 1992; honap: 7; nap : 29; megjegyzes: 'evfordulo'); 5.5. Tipuskonverzió A Turbo Pascalban a {$R-} direktíva megadása esetén adott a lehetőség, hogy különféle típuskonverziókat hajtsunk végre. Ehhez a kívánt típus neve után zárójelben kell megadni a konvertálandó kifejezést. Például: chr(65) integer('A') A TIPKONV.PAS programban karakter típust egésszé, egészt logikai értékké, karaktert pointerré, pointert valós típussá, valamint pointert sztringre mutató pointerré alakítottuk. (* tipkonv.pas *) {$R-} program tipuskonverzio; uses crt; var i : integer; w : word; c : char; b : boolean; p : pointer; r : real; s : string; begin clrscr; c:='b'; writeln('c = ',c); (* karakter konvertálása egésszé *) i:=integer(c); writeln('i = ',i); (* egész konvertálása boolean-ra *) b:=boolean(i); writeln('b = ',b); (* pointer értéke real változóba *) p:= @c; r:=real(p^); writeln('r = ',r:10); (* pointer értéke sztring-gé alakítva *) s:= string(p^); s[0]:=chr(1); writeln('s = ',s); end. A futtatás eredménye: c = b i = 98 b = TRUE r = 8.770E-10 s = b Ellenőrző kérdések: 1. Mit nevezünk változóknak? 2. Mi a változóazonosító? 3. Mi a kulcsszava a változók deklarálásának? 4. Melyek az elemi adattípusok? 5. Sorolja fel a numerikus információ tárolására szolgáló elemi adattípusokat? 6. Mekkora az értékkészlete az integer típusnak? 7. Mely egész típusú változók nem tartalmazhatnak negatív számokat? 8. Mikor érdemes longint típusúnak deklarálni egy egész típusú változót? 9. Mire használjuk a byte típusú változót? 10. Milyen különbség van a shortint és a byte között? 11. Hány fajta valós típusú változót használhatunk? 12. Melyik valós típus használható minden esetben? 13. Milyen nagyságrendű értéket tárolhat a real típusú változó ? 14. Mennyi az értékes jegyek száma a real típusú változók esetén? 15. Hány byte szükséges egy real típusú változó tárolásához? 16. Mikor kell használnunk double típusú változót? 17. Milyen legyen a deklaráció az alábbi változók esetében, ha v tartománya 0 és 125, m tartománya -20000 és 20000, i tartománya -200000 és 100000, k tartománya 0 és 65000, x lebegőpontos számokat tárol és tartománya a {EMBED Equation |} és {EMBED Equation |} közé esik, betu az ABC egy - egy betűit tartalmazza, nev 25 db karakterből álló nevet tárol, cim 32 db karakterből áló nevet tárol. 18. Logikai értékek tárolására milyen típusú változók alkalmasak? 19. Milyen kulcsszóval deklaráljuk a logikai típusú változókat? 20. Milyen értéket vehetnek fel a logikai típusú változók? 21. Milyen lehetőségek vannak a szöveges információ tárolására? 22. A karaktertípus mennyi helyet foglal le a memóriából? 23. A karaktersorozat tárolására milyen típusú változó alkalmas? 24. Egy string típusú változóban maximálisan mennyi karaktert tárolhatunk? 25. Ha egy nev nevű változóban csak 20 karaktert akarunk tárolni, akkor hogyan kell megadni a deklarációt? 26. Hogyan kell megadni a deklarációt, ha a kar változó csak egy karaktert tárol? 27. Milyen kulcsszó szükséges a típusdefinícióhoz? 28. Mit jelent a sorszámozott típus? 29. Mely típusok nem tartoznak a sorszámozott típusok közé? 30. Mit ad vissza az ord függvény? 31. Mire szolgál az succ függvény? 32. Mi lesz az értéke: succ(9); succ('b'); 33. Mire szolgál a pred függvény? 34. Mi lesz az értéke: pred(9), pred('b') 35. Mennyi a false sorszáma? 36. Mennyi a true sorszáma? 37. Mi lesz az értéke: suc(false); pred(true); ord(false); ord(true); 38. Mi a szintaktikája a felsorolt típusú változó deklarálásának? 39. Hozzunk létre egy felsorolt típust, azonosítója legyen osztalyzat elemei legyenek: elegtelen, elegseges, kozepes,jo,jeles,kitűnő Deklaráljunk az osztalyzat típusú erdemjegy változót. 40. Legyen adott az alábbi típus és változó deklaráció, mi lesz az eredménye a függvényhívásoknak: type alak=(szikar, sovany, karcsu, telt, kover); var szemely: alak; begin szemely:=(szikar,sovany,karcsu,telt,kover); succ(sovany); ord(szikar); pred(telt); ord(kover); 41. Hogyan kell definiálni a résztartomány típust? 42. Az alábbi programrészben milyen értékeket vehet fel az i változó: type hatar=1..100; var i: hatar; begin 43. A tömb milyen típusú elemekből áll? 44. Hogyan számítjuk ki a tömb helyfoglalását? 45. Mi a tömb megadás szintaxisa type és var kulcsszó esetén? 46. Legyen az adat 100 real típusú elemet tartalmazó tömbtípus, majd az x nevű tömböt deklaráljuk adat típusúnak? 47. Mit jelent az alábbi programrészlet type vektor =array[1..50] of integer; tomb =array[1..5,1..5] of real; var a,b : vektor; x : tomb; Mennyi a helyfoglalása az a és az x tömbnek? 48. Mi a tulajdonsága a record típusnak? 49. Hogyan kell megadni egy record típust? 50. Hogy hivatkozunk a record mezőire? 51. Adjuk kezdőértéket a teglalap típusú rekordnak, úgy hogy a szelesseg mezeje legyen 15, a magassag mezeje vegye fel a 8 értéket. A begin után írjuk fel az értékadó utasításokat. type teglalap = record szelesseg : integer; magassag : integer; end; var a: teglalap; begin 52. Milyen kulcsszó után lehet a konstansokat deklarálni? 53. Mi a szintaktikája a konstans megadásának? 54. Deklaráljuk az alábbi változókat konstansként minimum értéke -10 maximum értéke 1200 cim értéke 'Megoldas' karakter értéke '%' 55. A w valós tömbnek típusos konstansként adjunk értéket, ha elemeinek száma 5, és az alábbi értékeket vegye fel w[1] értéke 1.3 w[2] értéke 0.5 w[3] értéke 100.3 w[4] értéke -12.56 w[5] értéke -0.0017