Adatmennyiség: Bitek és bájtok

Adatmennyiségek

Az adatoknak is ugyanúgy van mennyisége, ahogy a tömegnek és az időnek, míg utóbbiaknak a fizikában, az adatmennyiségnek az információelméletben és mérnöki területeken, főként a programozásban van haszna.

Ahogy a hosszmérésnél a métert, időnél a másodpercet, tömegnél a grammot használjuk alapmértékegységnek, úgy az adatok alap mértékegysége a bit.

Egy bit információ egy eldöntendő kérdésre tud választ adni: Igen vagy nem, igaz, vagy hamis, 1 vagy 0.

Felismerhetjük, hogy ez a fogalom nagyon szoros kapcsolatban áll a bool típussal.

Egy bool változó pontosan egy bit információt tud tárolni.

A bit a legkisebb adatmennység, amit használunk, de Más mértékegységei is vannak az adatmennyiségeknek:

Byte = 8 bit
Word (vagy szó) = 16, 32 vagy 64 bit. Számítógéparchitektúrától függ.
Kilobyte = 1024 byte
Megabyte= 1024 Kilobyte
Gigabyte = 1024 Megabyte
Terrabyte = 1024 Gigabyte

Azért az 1024-et használjuk szorzónak és nem az 10-et, mert az 1024 pontosan 2 hatványa. Egészen pontosan a 10. hatványa: $(2^{10} = 1024)$

A számítástechnikában nagy szerep jut a logikai típusnak. Mi is tanultuk és sokat használtuk már a bool-t és annak műveleteit. Hogy ezt hogyan fejezzük ki bitekkel, az egyszerű: 1 == true és 0 == false.

Viszont ha ennél bonyolultabb típusokkal, egész és a tört számokkal, karakterekkel, szövegekkel dolgozunk, akkor valamiféle egyéb megoldásra lesz szükségünk.

10-es számrendszer és számábrázolás

Egész számok kifejezésére használható a kettes számrendszer. Ez teljesen megegyezik a mi jól megszokott 10-es rendszerünkkel, csupán kettő az alapja.

Ahogy a 10-es számrendszer 10 darab karaktert tartalmaz természetes számok leírására (0-9), úgy a bináris (kettes) számrendszer kettőt: a 0-t és az 1-et.

Gondoljuk végig, hogyan áll össze egy 10-es számrendszerbeli szám!

Vegyük a következő példát: 2 582 905

Ez a szám 2 * 1 000 000 + 5 * 100 000 + 8 * 10 000 + 2 * 1000 + 9 * 100 + 0 * 10 + 5 * 1

Szóval egy szám minden tizedesjegyét szorozzuk a 10 egy megfelelő hatványával és az eredményeket összeadjuk. Az, hogy a 10 melyik hatványával szorzunk, azt a helyi érték dönti el. Leghátul áll $10^0$ és ahogy haladunk balra, a nagyobb helyiértékek felé, egyre nő a kitevő.

2	5	8	2	9	0	5
$10^6$	$10^5$	$10^4$	$10^3$	$10^2$	$10^1$	$10^0$
1 000 000	100 000	10 000	1 000	100	10	1
$2 ×10^6$	$5 ×10^5$	$8 ×10^4$	$2 ×10^3$	$9 ×10^2$	$0 ×10^1$	$5 ×10^0$
2 000 000+	500 000 +	80 0000 +	2 0000 +	9000 +	0 +	5

= 2 582 905

Az, hogy miért épp 10-es számrendszert használunk a hétköznapokban, annak egyszerű az oka. Elég, ha a kezetekre néztek és rájöttök.

A kettes számrendszer

Vegyük most a következő kettes számrendszer béli példát: 11 011 101. Vajon milyen értéket takar ez? Hogy tudnánk kifejezni a fenti számot 10-es rendszerben?

Használjuk a 10-es számrendszerben megszokott módszert, csak a 10 hatványai helyett most a 2 hatványai jelöljék a különböző helyi értékeket:

1	1	0	1	1	1	0	1
$2^7$	$2^6$	$2^5$	$2^4$	$2^3$	$2^2$	$2^1$	$2^0$
128	64	32	16	8	4	2	1
$1 ×2^7$	$1 ×2^6$	$0×2^5$	$1 ×2^4$	$1×2^3$	$1 ×2^2$	$0 ×2^1$	$1 ×2^0$
128 +	64 +	0 +	16 +	8 +	4 +	0 +	1

= 221 (10-es számrendszerben kifejezve)

Ennyi a trükk! Ahogy azt bizonyára hallottad már, a modern számítógépek 2-es szemrendszert használnak a számításhoz, tehát az adatokat is ehhez hasonlóan, binárisan tároljuk el.

Ha tehát egy egész számot tárolunk el egy változóban az a háttérben binárisan lesz reprezentálva.

Ki kell emelni azonban, hogy nincs se tizedes vesszőnk, se minusz jelünk a hardveren, csak nullánk és egyesünk, tehát a fentiek csak előjel nélküli egészekre működnek. Hogy hogy lehet egyéb adatokat (negatív egészek, tört számok, karakterek…) ábrázolni kettes számrendszer segítségével, azzal itt foglalkozunk bővebben: Bináris adatok, bitműveletek (Hamarosan). Előjel nélküli egészeket azonban tudunk ábrázolni hagyományos kettes számrendszerben.

Adattípusok hossza:

Hogy hány számjegyünk van erre az meg fogja adni, mi a legmagasabb eltárolható előjel nélküli egész szám.

Gondoljuk végig mit is jelent ez 10-es számrendszerben. Ha egy számjegyet használhatok csak akkor a legmagasabb leírható szám a 9, ha kettő akkor a 99, ha három akkor a 999 és így tovább. tehát a következő képletet állíthatjuk fel:

Legmagasabb\ érték = 10^{számjegyek\ száma} -1

Ez átültethető kettes számrendszerre is:

Legmagasabb\ érték = 2^{számjegyek\ száma} -1

Tehát például a legnagyobb 10 jegyű bináris szám az 1111111111, ez 10-es számrendszerben kifejezve: $(2^{10} - 1) = (1024 -1) = 1023$

Mindennek azért van jelentősége, mert a C#-ban különböző hosszúságú típusokat használhatunk számok kifejezésére, tárolására.

C# beépített típusok

Előjel nélküli egész típusok:

Típus	Adatmennyiség	Minimum érték	Maximum érték
`byte`	8 bit = 1 byte	0	255 $(2^{8}-1)$
`ushort`	16 bit = 2 byte	0	65 535 $(2^{16}-1)$
`uint`	32 bit = 4 byte	0	4 294 967 295 $(2^{32}-1)$
`ulong`	64 bit = 8 byte	0	Őőő… jós sok $(2^{64}-1)$
`nuint`	Platformfüggő: 32 / 64	0	Platformfüggő

Tehát ha például 20 darab uint típusú változóra van szükségem, az pontosan 80 byte területet foglal el a memóriában.

Előjeles egészek, törtek és egyéb típusok bináris ábrázolását később tárgyaljuk, Ám addig is nézzük meg a többi beépített C# primitív típust is. Bináris adatok, bitműveletek (Hamarosan)

Előjeles nélküli egész típusok:

	Adatmennyiség	Minimum érték	Maximum érték
`sbyte`	8 bit = 1 byte	-128	127
`short`	16 bit = 2 byte	-32 768	32 767
`int`	32 bit = 4 byte	-2 147 483 648	2 147 483 647
`long`	64 bit = 8 byte	-9 223 372 036 854 775 808	9 223 372 036 854 775 807
`nint`	Platformfüggő: 32 / 64	Platformfüggő	Platformfüggő

Tehát például egy kilobyte memóriaterületen pontosan 128 long típusú számot tárolhatunk el. (1024 / 8 = 128)

Tört számok

	Adatmennyiség	Legkisebb szám nagyjából	Legnagyobb szám	Pontosság
`float`	32 bit = 4 byte	nagyjából $±1.5 ⋅ 10^{−45}$	nagyjából $±3.4 ⋅ 10^{38}$	6-9 számjegy
`double`	64 bit = 8 byte	nagyjából $±5 ⋅ 10^{−324}$	nagyjából $±1.7 ⋅ 10^{38}$	15-17 számjegy
`decimal`	128 bit = 16 byte	$±10^{−28}$	nagyjából $±7.9228 ⋅ 10^{28}$	28 számjegy

Ezek közül a float és a double máshogy működik, mint a decimal. Alapvető különbség használat szempontjából, hogy a double gyorsabb, nagyobb tartományon értelmezett és memóriatakarékosabb, a decimal pedig pontosabb 10-es számrendszerben, ezért használata pénzügyi applikációkban szokásos.

Unity-ben a 32 bites int-ek és float-ok használata javasolt, mivel a célhardware gyakran nem 64 bites. Ilyenek lehetnek mobil oprendszerek. Ekkor az int és a float használata jóval gyorsabb, mint a long és a double. Ennek azonban mára egyre kevesebb jelentősége van, mivel már a mobilok nagy része is 64 bites.

Egyéb beépített típusok

A maradék beépített típusok egyikének sincsen fix hossza.

char: Egy karaktert tárol el, ám mivel a karaktertábla változhat nem mindig ugyanannyi biten ebrázolt. (A default karakterkódolás C#-ba Unicode UTF-16 azaz alapesetben két byte-os minden karakter.)

string: Tetszőleges hosszú szöveg. Gyakorlatilag egy char tömb egyszerűsített változata.

object: Az összes típus ősosztálya, tehát bármilyen típusú adatot tárolhat. Bővebben itt: Objektum orientáltság és öröklés (Félkész)

dynamic: Típusbiztonság mentes kiegészítése a C#-nak. Bármilyen adatot tartalmazhat.