egyszerû adattípusok

• adattípusok általános jellemzõi
• a kettes (bináris) számrendszer használata
• a tizenhatos (hexadecimális) számrendszer használata
• a Turbo Pascal adattípusai
• a Java adattípusai

• értéktartomány
• helyfoglalás
• kódolás (adatábrázolás)
• szerkezet (összetett típusok esetén)
• komponensek típusa (pl. egy rekord mezõinek típusa)

• bináris számjegyek vagy bitek (0 és 1)
• helyiértékek (kettõ hatványai)
• 2⁰ = 1, 2¹ = 2, 2² = 4, 2³ = 8, 2⁴ = 16, 2⁵ = 32, 2⁶ = 64, 2⁷ = 128, 2⁸ = 256, ...
• bináris számrendszerben megadott egész szám átváltása decimális számrendszerbe
• példa: 1010₂ = 1*2³ + 0*2² + 1*2¹ + 0*2⁰ = 1*8 + 1*2 = 10₁₀
• decimális számrendszerben megadott egész szám átváltása bináris számrendszerbe
• példa: 179₁₀ =  10110011₂ (a számítás menete)
• bináris számrendszerben megadott törtszám ("kettedestört") átváltása decimális számrendszerbe (megjegyzés: a helyiértékek a "kettedespont" után 2 negatív egész hatványai lesznek, például 2^-1=1/2, 2^-2=1/4, 2^-3=1/8, stb.)
• példa: 0.101₂ = 1*(1/2) + 0*(1/4) + 1*(1/8) = (1/2) + (1/8) = 5/8 = 0.625₁₀
• decimális számrendszerben megadott törtszám (tizedestört) átváltása bináris számrendszerbe
• példa: 0.6875₁₀ = 0.1011₂ (a számítás menete)
• bináris számrendszerben megadott szám átváltása hexadecimális számrendszerbe (négyes számjegy-csoportok képzésével)
• példa: 10110011₂ = (1011₂)(0011₂) = (11₁₀)(3₁₀) = (B₁₆)(3₁₆) = B3₁₆
• hexadecimális számrendszerben megadott szám átváltása bináris számrendszerbe
• példa: A7₁₆ =  (A₁₆)(7₁₆) = (10₁₀)(7₁₀) = (1010₂)(0111₂) = 10100111₂

1. a táblázat elsõ sorának elsõ oszlopába az átváltandó számot írjuk be, ennek a sornak a második oszlopát üresen hagyjuk;
2. a táblázat további sorait - sorban egymás után - úgy számítjuk ki, hogy az utoljára kiszámított sor elsõ oszlopában szereplõ értéket (maradékosan) osztjuk 2-vel, és
• az osztás (egész) eredményét a következõ sor elsõ oszlopába,
• az osztás maradékát pedig ennek a sornak a második oszlopába írjuk;
3. ezt az eljárást addig folytatjuk, ameddig az osztás eredménye 0 nem lesz.

az eredményt úgy kapjuk, hogy a második oszlopban szereplõ maradékokat "visszafelé", azaz alulról felfelé olvassuk:
179 =  10110011₂

1. a táblázat elsõ sorának elsõ oszlopába 0-t, második oszlopába a tizedespontot, harmadik oszlopába pedig az átváltandó szám tizedespont utáni számjegyeit írjuk be;
2. a táblázat további sorait - sorban egymás után - úgy számítjuk ki, hogy az utoljára kiszámított sor elsõ oszlopában levõ egész értéket figyelmen kívül hagyjuk és csak a harmadik oszlopában szereplõ értéket szorozzuk 2-vel; a szorzás eredményét a következõ sorba írjuk:
• az egész értéket az elsõ oszlopba,
• a tizedespontot a második oszlopba, és
• a tizedespont utáni számjegyeket a harmadik oszlopba;
3. ezt az eljárást addig folytatjuk, ameddig a harmadik oszlopban 0-t nem kapunk.

az eredményt úgy kapjuk, hogy az elsõ oszlopban szereplõ egész értékeket felülrõl lefelé olvassuk:
0.6875₁₀ = 0.1011₂

• hexadecimális számjegyek
• decimális számjegyek (0,1,...,9)
• kiegészítõ számjegyek (A=10, B=11, C=12, D=13, E=14, F=15)
• hexadecimális helyiértékek (16 hatványai)
• 16⁰ = 1, 16¹ = 16, 16² = 256, 16³ = 4096, 16⁴ = 65536, ...
• hexadecimális számrendszerben megadott szám átváltása decimális számrendszerbe
• példa: A19₁₆ = 10*16² + 1*16¹ + 9*16⁰ = 10*256 + 1*16 + 9*1 = 2585₁₀
• decimális számrendszerben megadott szám átváltása hexadecimális számrendszerbe (a legegyszerûbb elõször a megadott számot bináris számrendszerbe átváltani, majd ezt négyes számjegy-csoportok képzésével egyszerûen hexadecimális számmá alakítani)
• példa: 2585₁₀ = (átváltás bináris számrendszerbe) = 101000011001₂ = (1010₂)(0001₂)(1001₂) = (10₁₀)(1₁₀)(9₁₀) = (A₁₆)(1₁₆)(9₁₆) = A19₁₆

• egyszerû (elemi) típusok
• sorszámozott vagy megszámlálható típusok (az értéktartomány elemeihez sorszámok rendelhetõek, amelyek természetes számok)
• valós típusok
• real (értéktartomány: kb. -2¹²⁷..+2¹²⁷ közötti valós számok max. 40 kettedesjegy pontossággal; helyfoglalás: 6 bájt; kódolás: lebegõpontos számábrázolás)
• matematikai társprocesszor használatát igénylõ valós típusok
• példa: a Turbo Pascal különbözõ valós típusainak pontossága
• karakterlánc típus (mivel a karakterláncot alkotó karakterek egyenként is elérhetõek, összetett típusnak is tekinthetõ!)
• összetett (strukturált) típusok (további típusokból, un. komponensekbõl épülnek fel)
• tömb (array; a komponensek azonos típusúak)
• rekord (record; a komponensek különbözõ típusúak)
• ...

• numerikus (egész) típusok
• egész vagy elõjeles típusok (az értéktartomány egész értékekbõl áll)
• elõjel nélküli típusok (az értéktartomány nemnegatív egész értékekbõl áll)
• byte (értéktartomány: 0..255; helyfoglalás: 1 bájt; kódolás: un. egyenes kódolás, azaz az értékek kettes számrendszerbeli alakja felel meg a biteknek)
• word (értéktartomány: 0..65535; helyfoglalás: 2 bájt; kódolás: egyenes kódolás)
• karakter típus
• char (értéktartomány: #0..#255, ahol pl. #65 az ASCII kódtábla 65-ös kódú karakterét jelenti (256 különbözõ karakter); helyfoglalás: 1 bájt; kódolás: ASCII, ill. a 7 bites ASCII kódrendszernek a számítógépen beállított kódtáblának megfelelõ, a nemzetközi karakterkészleteket is tartalmazó 8 bites kiterjesztése)
• a Turbo Pascal kiterjesztett karakterkódjai
• logikai típus
• Boolean (értéktartomány: False és True; helyfoglalás: 1 bájt; kódolás: a False értéknek a 00000000 érték felel meg, a True értéknek pedig bármilyen, ettõl különbözõ érték, alapértelmezésben 00000001)

• shortint (értéktartomány: -128..127 közötti egész számok; helyfoglalás: 1 bájt; kódolás: kettes komplemens kód)
• 1. példa: 1 kettes komplemens alakja 00000001 (egyenes kódolás pozitív számok esetén)
• 2. példa: -1 kettes komplemens alakja 11111111 (kettes komplemens kódolás negatív számok esetén)
• 1. lépés: |-1| = 1 egyenes kódban 00000001
• 2. lépés: 00000001 egyes komplemens kódban (komplementálva) 11111110
• 3. lépés: 11111110 + 1 = 11111111 (O.K.)
• 3. példa: a kettes komplemens kódban megadott 10101010 bitsorozatnak megfelelõ egész szám -86
• 1. lépés: 10101010 egyes komplemense 01010101
• 2. lépés: 01010101 + 1 = 01010110
• 3. lépés: egyenes kódolás esetén 01010110 = 64 + 16 + 4 + 2 = 86
• 4  lépés: az eredeti bitsorozat elõjelbitje 1 (negatív szám), tehát a végeredmény -86 (O.K.)
• integer (értéktartomány: -32768..32767 közötti egész számok; helyfoglalás: 2 bájt; kódolás: kettes komplemens kód)
• longint (értéktartomány: -2³¹..(2³¹-1) közötti egész számok; helyfoglalás: 4 bájt; kódolás: kettes komplemens kód)

• számábrázolás nem zérus érték esetén: kettes normálalakban (x = m*2^k)
• mantissza: 0.5 <= |m| < 1, m-et binárisan (kettedestört alakban) ábrázoljuk, elhagyva a kezdõ 0.1 tagot, amely minden m esetén megegyezik
• karakterisztika: -128 < k < 128, ahol k-t többleteskódban (k') ábrázoljuk (k' = k+128, ezért 0 < k' < 256)
• számábrázolás zérus érték esetén: az ábrázolt szám minden bitje 0
• megjegyzés: ha a legalacsonyabb helyiértékû bájt (LSB) minden bitje 0 (azaz ha normálalakban ábrázoljuk a számot, a karakterisztika -128), akkor a többi bájt értékétõl függetlenül az ábrázolt szám zérus, vagyis 0.5*2^-127-nél kisebb abszolút értékû számot a Turbo Pascal real típusa nem képes ábrázolni
• helyfoglalás: 6 bájt = 48 bit ( | 5. bájt = MSB | 4. bájt | ... | 1. bájt | 0. bájt = LSB | )
• MSB (Most Significant Byte; a legnagyobb helyiértékû bájt, amely a memóriában a legmagasabb memóriacímen helyezkedik el; a valós számot bitsorozatként ábrázolva ez a bal szélsõ bájt)
• bal szélsõ (legnagyobb helyiértékû) bit: elõjelbit (0 nemnegatív, 1 negatív számok esetén)
• további (alacsonyabb helyiértékû) 7 bit: a kettedestört alakban ábrázolt mantissza "kettedespont" utáni bináris számjegyei az elsõ (1/2-es helyiértékû) bit elhagyásával, azaz az 1/4-es helyiértéktõl kezdõdõen
• példa: ha m = 0.101₂ = 1*2^-1 + 0*2^-2 + 1*2^-3 = 1*0.5 + 0*0.25 + 1*0.125 = 0.625₁₀, akkor MSB = 00100000 (ha m nyolcnál kevesebb kettedesjegybõl áll, egyszerûen kiegészítjük megfelelõ számú nullával, ha pedig több kettedesjegybõl áll, ezeket az MSB utáni bájtokon ábrázoljuk, ld. alább)
• az MSB 7 alacsonyabb helyiértékû bitje, és a következõ 4 bájt (összesen 39 bit)
• az ábrázolt szám mantisszájának bináris számjegyei az 1/4-es helyiértéktõl kezdõdõen (mivel 0.5 <= |m| < 1 teljesül, ezért minden mantissza kettedestört alakban 0.1 módon kezdõdik, tehát elég csak az 1/2-es helyiérték utáni biteket ábrázolni)
• LSB (Least Significant Byte; a legkisebb helyiértékû bájt, amely a memóriában a legalacsonyabb memóriacímen helyezkedik el)
• az ábrázolt szám karakterisztikája többleteskódban (eltolva 128-cal)
• példák
• +2.9..*10^-39 = 0.5*2^-127 = |00000000|...|00000000|00000001|
• megjegyzés: ez a real típussal ábrázolható legkisebb nem zérus érték
• +0.25 = +0.5*2^-1 = |00000000|...|00000000|01111111|
• +0.5 = +0.5*2⁰ = |00000000|...|00000000|10000000|
• -0.5 = -0.5*2⁰ = |10000000|...|00000000|10000000|
• +0.625 = +0.625*2⁰ = |00100000|...|00000000|10000000|
• megjegyzés: 0.625 = 0.5 + 0.125 = 1/2 + 1/8, tehát a mantissza kettedestört alakban m = 0.101 (amelybõl csak a kezdõ 0.1 utáni bináris számjegyeket ábrázoljuk)
• +1 = +0.5*2¹ = |00000000|...|00000000|10000001|
• -2 = -0.5*2² = |10000000|...|00000000|10000010|
• +1.7..*10³⁸ = 0.99..*2¹²⁷ = |01111111|...|11111111|11111111|
• megjegyzés: ez a real típussal ábrázolható legnagyobb (pozitív) érték

• Single (4 bájtos lebegõpontos típus, 8 bites karakterisztikával)
• Double (8 bájtos lebegõpontos típus, 12 bites karakterisztikával)
• Extended (10 bájtos lebegõpontos típus, 15 bites karakterisztikával)

Pi értéke:  3.14159265358979324E+0000

• Single:     3.14159274101257E+0000 (hat tizedesjegyig pontos)
• Real:       3.14159265358830E+0000 (tizenegy tizedesjegyig pontos)
• Double:     3.14159265358979312E+0000 (tizenöt tizedesjegyig pontos)
• Extended:   3.14159265358979324E+0000

• Single:     2.71828174591064E+0000 (hat tizedesjegyig pontos)
• Real:       2.71828182846002E+0000 (tíz tizedesjegyig pontos)
• Double:     2.71828182845904509E+0000 (tizenöt tizedesjegyig pontos)
• Extended:   2.71828182845904524E+0000

• string (értéktartomány: az üres (0 karakter hosszúságú) string, továbbá minden elképzelhetõ karakterkombináció min. egy, max. 255 számú karakterbõl; helyfoglalás: 256 bájt; kódolás: a string legelsõ (0-s sorszámú) bájtja a stringben ténylegesen tárolt karakterek számát adja meg, a többi (1..255 sorszámú) bájton pedig a karakterek ASCII kódját tároljuk)
• a string típus olyan összetett adattípusnak is tekinthetõ, amelynek a komponensei a stringet alkotó karakterek, amelyek sorszámuk alapján közvetlenül is elérhetõek (pl. s:='Hello!'; értékadás után writeln(s[2]); az s string második karakterét, esetünkben az e karaktert fogja kiírni a képernyõre); azonban a karakter-típusú tömböktõl a stringeket megkülönbözteti a string aktuális hosszát megadó, 0-s sorszámú "karakter", amely karakter típusú tömbök esetén nem létezik
• példa: egy string karaktereinek kiírása egymás alá, külön sorokba
• csökkentett hosszúságú string (string[n], ahol n egy 1 és 255 közötti természetes szám, amely a stringben tárolható karakterek max. számát adja meg)

program pelda1;
uses crt;
var s:string[40];
       i,k:byte;
begin
write('Kérek egy max. 40 karakterbõl álló szöveget: ');
readln(s);
k:=byte(s[0]); {ugyanezt kapnánk a k:=length(s); utasítással is}
writeln('A string hossza: ',k);
for i:=1 to k do
    writeln(s[i]);
end.

• egyszerû, un. elemi típusok
• numerikus (egész és karakter) típusok
• byte (értéktartomány: -128..127; helyfoglalás: 1 bájt; kódolás: kettes komplemens kód)
• short (értéktartomány: -32768..32767; helyfoglalás: 2 bájt; kódolás: kettes komplemens kód)
• int (értéktartomány: -2³¹..(2³¹-1); helyfoglalás: 4 bájt; kódolás: kettes komplemens kód)
• long (értéktartomány: -2⁶³..(2⁶³-1); helyfoglalás: 8 bájt; kódolás: kettes komplemens kód)
• char (értéktartomány: 65536 különbözõ karakter; helyfoglalás: 2 bájt; kódolás: Unicode)
• numerikus (valós) típusok
• float (értéktartomány: kb. -2¹²⁸..2¹²⁸ közötti valós számok; helyfoglalás: 4 bájt; kódolás: lebegõpontos számábrázolás)
• double (értéktartomány: kb. -2¹⁰²⁴..2¹⁰²⁴ közötti valós számok; helyfoglalás: 8 bájt; kódolás: lebegõpontos számábrázolás)
• logikai típus
• boolean (értéktartomány: true vagy false; helyfoglalás: 1 bájt)
• összetett, un. referencia típusok
• objektum-típusok vagy osztályok (pl. String)
• tömbök (pl. String[] args)

• számábrázolás kettes normálalakban (x = m*2^k)
• karakterisztika: -1022 <= k < 1025, ahol k-t többleteskódban (k') ábrázoljuk (k' = k+1022, ezért 0<= k' < 2047)
• mantissza: m-et binárisan (kettedestört alakban) ábrázoljuk, és
• ha -1021 <= k <= 1024 akkor 0.5 <= |m| < 1, ábrázoláskor elhagyjuk a kezdõ 0.1 tagot, amely minden m esetén megegyezik (azaz csak a kettedespont és az utána, az 1/2 helyiértéken következõ 1 utáni bináris számjegyeket ábrázoljuk)
• ha k= -1022 akkor 0<= |m| < 1, ábrázoláskor elhagyjuk a kezdõ 0. tagot, amely minden m esetén megegyezik (azaz csak a kettedespont utáni bináris számjegyeket ábrázoljuk)
• helyfoglalás: 8 bájt
• MSB (Most Significant Byte; a legnagyobb helyiértékû bájt, amely a memóriában a legmagasabb memóriacímen helyezkedik el)
• bal szélsõ (legnagyobb helyiértékû) bit: elõjelbit (0 nemnegatív, 1 negatív számok esetén)
• az MSB 7 alacsonyabb helyiértékû bitje, és a következõ 4 bit (összesen 11 bit)
• az ábrázolt szám karakterisztikája többleteskódban (eltolva 1022-vel)
• az MSB utáni bájt alacsonyabb helyiértékû 4 bitje és a következõ 6 bájt 6*8 = 48 bitje (összesen 52 bit)
• ha a karakterisztika = -1022, az ábrázolt szám mantisszájának bináris számjegyei az 1/2-es helyiértéktõl kezdõdõen (0. után)
• az ábrázolható legkisebb (nem 0) érték: 2^-52 * 2^-1022 = 2^-1074
• ha a karakterisztika -1021 és +1024 közé esik, akkor az ábrázolt szám mantisszájának bináris számjegyei az 1/4-es helyiértéktõl kezdõdõen (0.1 után)
• az ábrázolható legnagyobb érték: 0.99.....9 * 2¹⁰²⁴ ~ 2¹⁰²⁴
• ha a karakterisztika +1025, akkor vagy un. pozitív / negatív végtelen, vagy un. NaN (Not-a-Number) értéket kapunk (ez kb. megfelel a lebegõpontos túlcsordulásnak)
• példák ( | 7. bájt = MSB | 6. bájt | ... | 1. bájt | 0. bájt = LSB | alakban megadva az ábrázolt értékeket)
• +4.9*10^-324(Double.MIN_VALUE) = +1.0*2^-1074 = |00000000|00000000|00000000|...|00000001|
• +0.25 = +0.5*2^-1 = |00111111|11010000|00000000|...|00000000|
• +0.5 = +0.5*2⁰ = |00111111|11100000|00000000|...|00000000|
• -0.5 = -0.5*2⁰ = |10111111|11100000|00000000|...|00000000|
• +0.625 = +0.625*2⁰ = |00111111|11100100|00000000|...|00000000|
• megjegyzés: 0.625 = 0.5 + 0.125 = 1/2 + 1/8, tehát a mantissza kettedestört alakban m = 0.101 (amelybõl csak a kezdõ 0.1 utáni bináris számjegyeket ábrázoljuk)
• +1 = +0.5*2¹ = |00111111|11110000|00000000|...|00000000|
• -2 = -0.5*2² = |11000000|00000000|00000000|...|00000000|
• +1.7976931348623157*10³⁰⁸ (Double.MAX_VALUE) = +0.99...9*2¹⁰²⁴ = |01111111|11101111|11111111|...|11111111|
• +1.0/0.0 (Double.POSITIVE_INFINITY; formálisan +0.5*2¹⁰²⁵) = |01111111|11110000|00000000|...|00000000|
• -1.0/0.0 (Double.NEGATIVE_INFINITY; formálisan -0.5*2¹⁰²⁵) = |11111111|11110000|00000000|...|00000000|
• Not-a-Number (Double.NaN; formálisan +0.75*2¹⁰²⁵) = |01111111|11111000|00000000|...|00000000|