Elemi adattípusok (adatabrazolas, értéktartomany, konstansok, mûveletek, fontosabb függvények, eljarasok)

Elemi adattípusok (adatábrázolás, értéktartomány, konstansok, mûveletek, fontosabb függvények, eljárások)

A Pascal nyelv erõsen típusos nyelv, azaz minden a programban felhasználásra kerülõ változó típusát elõre meg kell határozni. A nyelv jónéhány elõre definiált standard típust tartalmaz, amelyet kiegészítenek a unit-okban definiált típusok is. Az elõbbiek bármely programban szabadon felhasználhatók, az utóbbiak használata elõtt a Uses utasítás segítségével meg kell hívni a típust tartalmazó unit-ot. A beépített és a unit-ok által rendelkezére bocsátott típusokon kívül lehetõségünk van a deklarációs részben saját típusok definiálására (deklarálására) is. Álalános szabály, hogy a változó bármely ismert típust felveheti, azaz a változó deklarációjának helye elõtt ismertté kell tenni a típust a fordító számára (unit-hívás, típusdeklaráció, ha nem standard típus).
A Turbo Pascal nyelv típusait a következõképpen csoportosíthatjuk:

Egyszerû típusok:
    - Sorszámozott típusok:
        - Egész típusok
        - Karakteres típus
        - Logikai típus
        - Felsorolt típus
        - Résztartomány típus

    - Valós típusok
 
    - String típus
 

Struktúrált (összetett) típusok:
    - Tömb típusok

    - File típusok

    - Record típus

    - Halmaz típus

    - Objektum típus

Mutató típusok

A típusok csopor 313i87d tosítása során a szempont az adott típusú változókon végezhetõ mûveletek köre volt, azonos csoportba tartozó típusokon hasonló mûveleteket lehet elvégezni.
 
 

Egyszerû (elemi) adattípusok:

Az elemi adattípsok közös jellemzõje, hogy az ilyen típusú változók egyszerre csak egy értéket képesek tárolni, értelmezési tartományuknak megfelelõen. Az elemi adattípusokat három alcsoportra osztottuk, az egyes alcsoportokba tartozó típusok hasonló jellemzõkkel, tulajdonságokkal rendelkeznek.
A sorszámozott típusoknál az értelmezési tartomány minden egyes eleme esetében egyértelmûen meghatározható az elemet megelõzõ és az elemet követõ elem (Pld: 1, 2, 3 vagy a, b, c).
A valós típusok esetében az elõbbi kijelentés már nem igaz, mivel két valós érték között még végtelen sok valós érték található.
A string típus esetében megoszlanak a vélemények arról, hogy egyszerû adattípus-e egyáltalán. Kezelését tekintve valóban tekinthetõ összetett típusnak (hiszen tulajdonképpen egy tömb, amelynek elemei karakter típusúak), de mivel string típusú változó szerepelhet a függvények paraméterlistájában, általában az egyszerû típusok közé sorolják.

A sorszámozott típusok csoportját további alcsoportokra bonthatjuk:
- numerikus típusok
- karakteres típus
- egyéb típusok (felhasználó által létrehozott típusok)

A numerikus típusok:

Egész típusok:

Numerikus értékek, egész számok tárolására alkalmas típusok (a nevébõl következtetni lehet erre... :-))) ). Valós értékek tárolására alkalmatlanok. Aritmetikai mûveletek során használhatjuk fel ezeket a típusokat.

A Turbo Pascal-ban ötféle elõre definiált egész típus áll rendelkezésre:
 

Az egész típusok memóriában történõ tárolása fixpontos ábrázolás szerint történik. Az alábbiakban az Integer típus ábrázolásán keresztül nézzük meg a fixpontos számábrázolás lényegét:

Az Integer típus 2 byte-ot foglal a memóriában. Ez elméletileg 2¹⁶ féle (65536) szám ábrázolását tenné lehetõvé, de ekkor csak pozitív számokat tudunk ábrázolni. Ebben a legegyszerûbb esetben nem kell mást tennünk, mint a számot átalakítani 2-es számrendszerbe, és kiegészíteni annyi 0-val, amely kitölti a 16 bitet. (A word típus így mûködik.)
Azonban szükségünk van negatív számokra is, melyeknek tárolására már nem megfelelõ az elõbbi módszer (honnan tudjuk, hogy a szám milyen elõjelû lesz?). A negatív számok ábrázolásához alkalmazták az ún. elõjelbitet, azaz a két byte legelsõ bitje határozza meg, hogy a szám milyen elõjelet kap. Ha az elõjelbit 0, akkor a szám pozitív, ha 1, a szám negatív. Az elõjelbit alkalmazása csökkenti az ábrázolható számok értelmezési tartományát, mivel a 16 bitbõl egy az elõjelet határozza meg. Ilyen módon a legnagyobb ábrázolható szám 2¹⁵-1, azaz 32767 lesz. Ezt a legnagyobb számot a következõképpen ábrázolhatjuk:
0111111111111111₂=32767₁₀

A pozitív számok tárolása tehát a fentebb vázolt módszerrel történik (azért még késõbb bonyolódni fog). A negatív számok ábrázolása során a gyorsabb számolás érdekében a szám a 16 bit szerinti kettes komplemens formában van tárolva. A kettes komplemens kód képzése során elõször kiszámoljuk a szám kettes számrendszerbeli formájának inverzét, majd az így kapott számhoz hozzáadunk egyet. Nézzünk egy példát:
Ábrázoljunk -18 at kettes komplemes kódban:

18 kettes számrendszerbeli alakja: 0000000000010010
inverze:                 1111111111101101
hozzáadva 1-et:            1111111111101110

A legnagyobb 16 biten ábrázolható negatív szám a -1, a legkisebb -32768.

A fixpontos számábrázolás során amennyiben a típus 1 byte-nál nagyobb méretû, a szomszédos byte-okat felcseréljük, az ábrázolás byte-fordított formában történik. A byte fordított forma jellemzõ mind a pozitív, mind a negatív számok ábrázolása során.

Nézzük ezek után az egyes egész típusok jellemzõit.

Shortint:

Értelmezési tartománya -128..127. Elõjeles típus, mérete 1 byte. A negatív számok ábrázolása kettes komplemens kódban történik, a típus méretébõl adódóan a byte-fordított forma nem jellemzõ. :-))

Byte:
Értelmezési tartománya 0..255. Elõjel nélküli típus, mérete 1 byte. A számok ábrázolása normál kettes számrendszerbeli alakjukkal történik, a byte-fordított forma és a kettes komplemens kód nem jellemzõ.

Word:
Értelmezési tartománya 0..65535. Elõjel nélküli típus, mérete 2 byte. A számok ábrázolása kettes számrendszerbeli alakban történik, byte-fordított formában.

Integer:
Értelmezési tartománya -32767..32768. Elõjeles típus, mérete 2 byte. A pozitív számok ábrázolása kettes számrendszerbeli alakjukkal, a negatív számok ábrázolása kettes komplemens kódban történik. Jellemzõ a byte-fordított tárolási forma.

Longint:
Értelmezési tartománya -2147483648..2147483647. Elõjeles típus, mérete 4 byte. A pozitív számok ábrázolása kettes számrendszerbeli alakban, a negatív számok ábrázolása kettes komplemens kódban történik. Jellemzõ a byte-fordított tárolási forma.

Comp:
Ez a típus a kevésbé ismert típusok közé tartozik, elég ritkán használjuk. A legnagyobb méretû egész típus,  értelmezési tartománya -9,22*10^-18..9,22*10¹⁸. Memóriában történõ tárolása az integer-hez hasonlóan, fixpontos, byte-fordított formában történik. A negatív számokat 64 bit szerinti kettes komplemens kódban tárolja.
Az egészek között ez az egyetlen típus, amely igényli az aritmetikai társprocesszor jelenlétét, illetve ha fizikailag nincs, akkor annak emulációját. (Az N, és szükség esetén az E direktívát be kell kapcsolni.)
A comp típust sokszor a valósak közé sorolják, mert igaz, hogy ábrázolása fixpontosan történik, de legtöbb egész paramétert váró függvény nem fogadja el a comp típust, illetve amikor egy ilyen változó tartalmát alapértelmezés szerint iratjuk ki a képernyõre, az eredmény lebegõpontosan jelenik meg.
 
Valós típusok:
 
Valós számok (tizedestörtek) tárolására használhatjuk ezeket a típusokat. Természetesen tárolhatók egész számok is, de a valós típusú változóban tárolt egész számok teljesen eltérõen viselkednek az elõbbiekben tárgyalt egész típusú változókban tárolt egész számokhoz képest. A valós típusok az aritmetikai mûveletek sokkal szélesebb körét támogatják, mint az egész típusok.

A Turbo Pascal-ban négyféle valós típust használhatunk:
 
 

A valós számok ábrázolása a memóriában lebegõpontosan történik (ebbõl kifolyólag más jellemzõket írtam a táblázatba is, mint az egészek esetén). A lebegõpontos ábrázolás során a számot normál alakban tároljuk, tehát a következõ formában:
x=m*2^k
ahol x a tárolandó szám, m a mantissza, k a karakterisztika. Az értékek (x, m, k) nyilván 2-es számrendszerbeli formában vannak tárolva. A típus teljes méretét kiszámolhatjuk, ha összeadjuk a mantissza és a karakterisztika tárolásához szükséges biteket, majd a kapott értékhez hozzáadunk egyet, az elõjelbit miatt.
Tehát a negatív számok tárolását itt is egy elõjelbit által oldották meg. Az elõjelbit a mantissza elõjelét tárolja, tehát a teljes szám elõjelét határozza meg. Az elõjelbit a mantissza elõtt alló legelsõ bit lesz.
A karakterisztika tárolási mérete határozza meg a tárolható számok pontosságának mértékét (tizedesjegyek száma). Nyilvánvaló, hogy a 0-hoz közeli számok tárolását a karakterisztika negatív értékével lehet megvalósítani. Ehhez szükség lenne (elméletileg) még egy elõjelbitre, mivel a mantissza és a karakterisztika elõjele egymástól független. Annak érdekében, hogy ne kelljen még egy bitet feláldozni az elõjel tárolásához, a karakterisztika tárolása eltolt ábrázolással történik. Nézzük meg a Real típus esetében hogyan történik az eltolt ábrázolás:
A Real karakterisztikája $80-nal van eltolva. Ha a karaketerisztika értéke 3 lesz (azaz a mantisszát 2³-nal kell szorozni), akkor a karakterisztika ábrázolt értéke $83 lesz, tehát a tényleges karakterisztika számításához ki kell vonnunk az ábrázolt értékbõl $80-at. Amennyiben negatív kitevõt szeretnénk ábrázolni, hasonlóképpen kell eljárnunk. Ha a karakterisztika értéke -5 lesz, akkor az ábrázolt érték: $75. Ebbõl kivonva a $80-at, eredményül -5-öt kapunk.
Természetesen a valós típusok esetén is érvényes a byte-fordított tárolási forma, tehát a lebegõpontos ábrázolás során is fel kell cserélni a szomszédos byte-okat a pontos tárolási kép meghatározása során.
A valós típusok közül egyedül a Real típus nem igényli a numerikus processzor (8087) jelenlétét (illetve emulációját), az összes többi valós típusnak szüksége van erre. Amennyiben gépünk tartamaz numerikus processzort, a program elején (legalábbis a valós típusok deklarálása elõtt) az N direktívát be kell kapcsolni, hogy a programunk kihasználhassa a numerikus processzort. Amennyiben ezt nem tesszük meg, a fordító hibaüzenetet fog küldeni a Real-tõl különbözõ valós típusok használata esetén.
Ha gépünkben nincs numerikus processzor, a Turbo Pascal (5.5 és annál újabb változatai) képesek azt emulálni az E direktíva bekapcsolása esetén. Tehát amennyiben van numerikus processzorunk: , amennyiben nincs:
Ha esetleg ebben a formában érthetõbb:

Nézzük ezek után az egyes valós típusok jellemzõit.

Real:

Értelmezési tartománya 2.9*10^-39..1.7*10³⁸. Mérete 6 byte. A Turbo Pascal elsõ verziójától használható valós típus, az egyetlen valós típus, amely nem igényli a numerikus processzort. Pontossága 11-12 tizedesjegy. Ezt a típus használjuk leggyakrabban a valós számok tárolásához.

Single:
Értelmezési tartománya 1.4*10^-45..3.4*10³⁸. Mérete 4 byte. A Turbo Pascal 4.0 verziójától használható valós típus, igényli a numerikus processzort vagy annak emulációját. Pontossága 7-8 tizedesjegy.

Double:
Értelmezési tartománya 4.9*10^-324..1.7*10³⁰⁸. Mérete 8 byte. A Turbo Pascal 4.0 verziójától használható, igényli a numerikus processzort vagy annak emulációját. Pontossága: 15-16 tizedesjegy.

Extended:
Értelmezési tartománya 3.3*10^-4932..1.1*10⁴⁹³². Mérete 10 byte. A Turbo Pascal 4.0 verziójától használható, igényli a numerikus processzort vagy annak emulációját. Pontossága: 19-20 tizedesjegy.
 
 

A karekteres típus:

Ebbe a csoportba egyetlen típust szoktunk sorolni, a char típust. Ez a típus egyetlen ASCII karakter tárolását teszi lehetõvé. A típus mérete 1 byte, elõjel nélküli típus. Tehát egy char típusú változóban 2⁸ (256) féle értéket tudunk tárolni. Értelmezési tartománya az ASCII kódtábla elsõ karakterétõl, az utolsó karakteréig tart.
A memóriában történõ tárolása a byte típushoz hasonlóan történik, valójában a karakter ASCII kódjának kettes számrendszerbeli formáját tároljuk. A képernyõn történõ megjelenítéskor a tárolt karakter jelenik meg.
 

A logikai típus:

A Pascal nyelv egyik speciális lehetõsége, hogy beépített logikai típussal rendelkezik, ez a Boolean típus. (Más nyelvek általában egész változókkal oldják meg.) Ez a típus mindössze kétféle érték tárolására képes: logikai igaz (TRUE) és logikai hamis (FALSE). A típus a memóriában 1 byte-on tárolható. A TRUE(=1)FALSE(=0) reláció természetesen igaz. A képernyõn történõ megjelenítés során a változó értéke szöveges formában kerül kiírásra, végig nagybetûvel írva.
 

A felsorolt típus:

A Pascal nyelv lehetõséget ad arra, hogy a program írása során olyan egyedi típusokat deklaráljunk, amelyeknek értékkészletét magunk határozzuk meg. Ezek a típusok mindig sorszámozott típusok, az elemek azonosítóit azonban mi magunk adhatjuk meg. A felsorolt típus elemeinek felsorolása egyben nagyságrendi sorrendet is meghatároz, mivel a fordító automatikusan sorszámot rendel az egyes elemekhez. Ha másképpen nem rendelkezünk, az elsõ elem a 0 sorszámot kapja, a következõ elemek sorszáma pedig mindig eggyel növekszik az elõzõhöz képest. Nézzünk erre egy egyszerû példát:

var Het: (Hetfo, Kedd, Szerda, Csutortok, Pentek, Szombat, Vasarnap);

A fesorolt típus deklarációja során az értékkészlet elemeit kerek zárójelek között, egymástól vesszõvel elválasztva soroljuk fel. A sorszámozás ebben az esetben automatikus, tehát a Hetfo a 0 sorszámot kapta, Pentek pedig a 4-et. Nagyon fontos, hogy az egyedi azonosítókat nem kell aposztrófok közé tenni, mivel nem stringekrõl van szó.
A felsorolt típussal deklarált azonosító csak olyan értéket vehet fel, amely a felsorolásban szerepel.
A felsorolt típus memóriában történõ ábrázolása 1 byte-on történik.
 

A résztartomány típus:

A neve is mutatja ennek a típusnak a jelentõségét. A már ismert sorszámozott típusok egy-egy része, tartománya külö típusként használható a program során. Sokszor hasznos ez a lehetõség, ha tudjuk, hogy a felhasznált értékek milyen intervallumba fognak esni.
A résztartomány típus deklarációja során a típus alsó és felsõ határértékeit kell feltüntetni, intervallum formájában. Például:

Var
Számjegy: '0'..'9';
Nagybetu: 'A'..'Z';
Egyjegyu: 0..9;
Ketjegyu: 10..99;
Haromjegyu: 100..999;

A fenti forma alkalmazható a Var utasítás után. Ha külön típusként szeretnénk felhasználni:

type Szamjegy= '0'..'9';
...
var S: Szamjegy;

A felsorolt típusok memóriabeli mérete a típus felsõ határától függ. Mindig akkora területet használ fel a fordító, amely minimálisan szükséges a felsõ érték tárolásához. Pld: 0..65000 tárolásához két byte szükséges, de 0..66000 tárolásához már négy byte.
A felsorolt típusok tárolása kettes komplemens kódban történik, több byte-os típusok esetén byte-fordított formában.
 

A string típus:
 
Ez a típus szöveges adatok tárolását teszi lehetõvé. Tulajdonképpen karakterek egymáshoz fûzött láncát jelenti. Az egymáshoz fûzött karakterek láncának hossza változó, mindössze a karakterek maximális száma van rögzítve, a legnagyobb hosszúság 255 karakter lehet. A string aktuális hosszán az éppen tárolt karakterek számát értjük. A string típus megítélése során eltérõek a vélemények: mivel karakterekbõl álló tömbrõl van szó, egyesek szerint az összetett típusok közé kellene sorolni. Mivel azonban a string típus a függvény paramétere is lehet, mások az egyszerû típusok közé sorolják. A stringek deklarációja:
Var S1: String;
Ez a deklaráció legegyszerûbb formája, ebben az esetben a string maximális hosszsága 255 karakter lehet. A deklaráció során meg lehet határozni a változóban tárolható szöveg legnagyobb hosszúságát a következõ módon:
Var S2: String[20];
Ebben az esetben a tárolható szöveg maximum 20 karakterõl állhat. A String típusú változók értéke beolvasható a billentyûzetrõl. Amennyiben a felhasználó a deklarált maximális hosszúságnál hosszabb szöveget szeretne megadni, a szövegnek csak az a része kerül tárolásra, amennyit a változó hosszúsága megenged, tehát csonkolás történik.
A string változók maximális hosszúságára vonatozó korlátozás a string típus felépítésében keresendõ. A stringek memóriában történõ tárolása igen egyszerû: minden karakter egy byte-on van ábrázolva, ASCII kódjának kettes számrendszerbeli alakjában, az egyes karakterek egymás után helyezkednek el. A string hosszúsága (memóriabeli mérete) a következõképpen határozható meg: a deklarációban szereplõ maximális hosszúsághoz hozzáadunk egyet. Tehát a Var S: String deklaráció által létrehozott változó a memóriában 256 byte-ot foglal. A stringek 0. byte-ja speciális feladatot lát el a string kezelése során, ez a byte tárolja a string aktuális hosszúságát. A 0. byte-ot általában "nem illik" módosítani.
Tehát egy string tárolását a következõképpen lehet elképzeni:

Var S: String[6];
Begin
    S:= 'AAAA';
End.

Az S string memóriában történõ tárolása:
 

Tehát látható, hogy a string hosszúságát is egy ASCII karakterként tároljuk a string 0. byte-jában. Mivel a string aktuális hosszúsága 4 karakter, az ötödik és hatodik byte értéke nem meghatározható.

A string típusú változók szoros kapcsolatban állnak a tömbökkel. A string változó egyes byte-jai ugyanúgy érhetõk el, ahogy egy tömb elemei. Nyilván itt is figyelni kell az indexelés határaira. A string minden egyes byte-ja (karaktere) egy karakter típusú értéknek felel meg.

Var S: String[20];
       Ch: Char;
Begin
    S:= 'Pascal';
    Ch:= S[3];
    Writeln(Ch);
End.

A program eredményként az "s" betût fogja kiírni.
 
 

Az egyszerû típusokhoz kapcsolódó eljárások, függvények:
 
Az egyszerû típusokon elvégezhetõ függvények, eljárások a System unit-ban vannak definiálva. Az eljárások, függvények mellett az egyszerû típusok felhasználhatók a Pascal kifejezések operandusaiként is, lásd a 6. tételben.

A függvények, eljárások a hozzájuk kapcsolódó típusok szerint csoportokra oszthatók:

Matematikai függvények, eljárások:
A numerikus típusokhoz kapcsolódó függvények, eljárások. Az eredmény, és a paraméterek jellegétõl függõen valós, illetve egész típusokon alkalmazhatók.

Abs(x)    Az x paraméter abszolút értéke. x: valós, egész. Eredmény: egész.
ArcTan(x)    Az x paraméter arkusztangense (a tangens inverze). x: valós, egész. Eredmény: valós.
Cos(x)    Az x paraméter koszinusza. A szöget radiánban kell megadni. x: valós, egész. Eredmény: valós.
Exp(x)    Az x paraméter e alapú hatványa (exponenciálisa). Eredmény: valós.
Frac(x)    Az x paraméter törtrésze. x: valós, egész. Eredmény: valós.
Int(x)    Az x paraméter egészrésze (kerekítés nélkül). x: valós, egész. Eredmény: egész.
Ln(x)    Az x paraméter 10-es alapú logaritmusa. x: valós, egész. Eredmény: valós.
Odd(x)    Paritás tesztelése (páros szám-e x). x: egész. Eredmény: logikai (False- páros, True- páratlan)
Pi    Pi értéke.
Random    0 és 1 közé esõ véletlenszám elõállítása. Eredmény: valós.
Random(x)    0 és x közé esõ véletlenszám elõállítása. x: egész. Eredmény: egész.
Randomize    A véletlenszám generátor indítása. (Véletlenszám elõállítása elõtt mindenképpen szükséges)
Round(x)    Az x paraméter kerekített értékét adja vissza. x: valós, egész. Eredmény: egész.
Sin(x)    Az x paraméter szinusza. A szöget radiánban kell megadni. x: valós, egész. Eredmény: valós.
Sqr(x)    Az x paraméter négyzete. x: valós, egész. Eredmény: x típusától függ.
Sqrt(x)    Az x paraméter négyzetgyöke. x: valós, egész. Eredmény: x típusától függ.
Trunc(x)    Valós típusú érték 0 felé kerekített egész része, azaz a valós érték tizedespont utáni részét "levágja". x: valós. Eredmény: egész.
 

Sorszámozott típusokhoz kapcsolódó függvények, eljárások:
Ezek az eljárások, függvények kizárólag sorszámozott típusok esetében alkalmazhatók, paraméterük, eredményük egyaránt sorszámozott típus kell legyen.

Dec(x)    Az x paraméter értékének csökkentése 1-gyel.
Dec(x, n)    Az x paraméter értékének csökkentése n-nel.
Inc(x)    Az x paraméter értékének növelése 1-gyel.
Inc(x, n)    Az x paraméter értékének növelése n-nel.
Ord(x)    Az x paraméter sorszámának értéke (pld. Karakterek esetén ASCII kód)
Pred(x)    Az x paramétert megelõzõ érték. (pld. Ch:= Pred('B'); Ch értéke: 'A')
Succ(x)    Az x paramétert követkõ érték. (pld. Ch:= Succ('B'); Ch értéke: 'C')
Chr(x)    Az x paraméter által meghatározott (ASCII kódú) karakter (pld: Ch:= Chr(65); Ch értéke: 'A')
 

Stringekhez kapcsolódó függvények, eljárások:
Ezek az eljárások a karakterláncok kezelését segítik. Található közöttük néhány olyan eljárás, amely egy Pascal kifejezésen kereszül is megoldható, ezekben az esetekben a programozó dönti el, hogy melyik megoldást választja.

Concat(S1, S2, ...)    A függvény összefûzi a paraméterlistában szereplõ stringeket. A paraméterek száma nincs meghatározva.
Copy(S, I, N)    A függvény az S stringbõl kimásol N darab karaktert, az I. karakterõl kezdõdõen. S: String, I, N: Byte.
Delete(S, I, N)    Az eljárás az S stringbõl töröl N darab karaktert, az I. karakterõl kezdõdõen. S: String, I, N: Byte.
Insert(S1, S2, I)    Az eljárás S1 string I. karaktere után beszúrja az S2 stringet.
Length(S)    A függvény visszaadja az S string hosszúságát. Eredmény: egész.
Pos(S1, S2)    A függvény az S2 stringben keresi S1 stringet. Ha megtalálta, akkor egész értékként adja vissza, hol kezdõdik S2-ben S1, ha nem találta meg, 0 értéket ad vissza.
Str(X:W, S)    Az eljárás X egész értéket szöveggé alakítja át W mezõszélességgel. Eredmény: string (S).
Str(X:W:D, S)    Az eljárás X valós értéket szöveggé alakítja át W:D mezõszélességgel (W:D - egészrész : tizedesjegyek) Eredmény: string (S).
UpCase(CH)    Az eljárás a CH karaktert átalakítja nagybetûvé. A CH típusa karakter (Char), csak az angol ABC betûivel mûködik helyesen.
Val(S, V, Code)    Az eljárás S stringet alakítja át numerikus értékké. A numerikus érték típusát a V paraméter típusa határozza meg, egész és valós egyaránt lehet. Ha hiba történt az átalakítás során, a hiba fellépésének helyét a Code egész típusú változó tartalmazza. Hiba nélküli átalakítás esetén Code értéke 0.