Amikor programozásban, elektronikában vagy akár játékkészítésben dolgozunk, a számítógépnek mindig pontosan tudnia kell, mekkora számokat tud kezelni.
Ebben  az úgynevezett egész típusú számrendszerek (integer number systems) segítenek neki.

A számítógép számára minden adat bitekből – vagyis 0-kból és 1-ekből – áll.
Ha például 8 bitet kapsz, az azt jelenti, hogy 8 helyed van, és minden helyen vagy 0, vagy 1 állhat.

Mit jelent az, hogy „N biten → 2ⁿ lehetséges érték ábrázolható”?

Minden bit két lehetőséget ad, így az összes kombináció száma:
👉 2 × 2 × 2 × … × 2 (N-szer)
Ez pedig nem más, mint 2ⁿ.

Például:

• 1 bit → 2 érték (0 vagy 1)

• 2 bit → 4 érték (00, 01, 10, 11)

• 3 bit → 8 érték

• 8 bit → 256 érték (0–255)

• 16 bit → 65 536 érték

• 32 bit → 4 294 967 296 érték 🤯

Ezért mondjuk, hogy N biten 2ⁿ lehetséges értéket tudunk ábrázolni. Minél több a bit, annál nagyobb számokat tud a gép kezelni.
Vagyis: több memória = nagyobb szám = boldogabb programozó 😎

Most, hogy tudod, hogyan működik az előjelbit, nézzük meg, mit jelent ez a gyakorlatban!
A számítógépek különböző méretű egész típusokat használnak – attól függően, mennyi memóriát szánunk a szám tárolására.

• short integer (2 byte = 16 bit)

  • 1 bit az előjel, 15 bit az érték

  • Tartomány: –32 768 ≤ V ≤ 32 767

• integer (4 byte = 32 bit)

  • 1 előjelbit + 31 értékbit

  • Tartomány: kb. –2 × 10⁹ ≤ V ≤ 2 × 10⁹

• long integer (8 byte = 64 bit)

  • 1 előjelbit + 63 értékbit

  • Tartomány: kb. –9 × 10¹⁸ ≤ V ≤ 9 × 10¹⁸

Ezeket a határokat a 2ⁿ képletből vezethetjük le – ahol az egyik bit mindig az előjelre megy el.
Tehát az előjeles számoknál a tartomány kicsit szűkül: ➡️ –2ⁿ⁻¹ … 2ⁿ⁻¹ – 1

A számítógép-architektúrában az egész típusú adattípusok a processzor regisztereinek szélességéhez igazodnak.
Például az első IBM-PC-k 16 bites Intel 8086 processzort használtak, ezért ott a „short integer” volt az alap típus, hiszen a CPU egyszerre 16 bitet tudott feldolgozni.
Később, a 32 bites (Intel 80386) korszakban az „integer” vált alapértelmezetté, majd a modern 64 bites processzoroknál a „long integer” lett a természetes egység.
Ezért ma, ha egy változót deklarálsz, a gép valójában a hardver korlátaihoz igazítja a méretét.

⚙️ Miért pont 2ⁿ⁻¹ … 2ⁿ⁻¹ − 1?

Az előjeles egész számok tartománya nem véletlenül ilyen furcsa.
Azért aszimmetrikus (pl. –32 768 → 32 767), mert a legfelső bit az előjelet hordozza, és a 0-t csak egyszer lehet kódolni.
Matematikailag a 2’s komplement rendszer a leghatékonyabb, mert:

• egyetlen hardveres összeadómű elegendő mind összeadásra és kivonásra,

• a „+0” és „–0” azonos bitmintát kap (így nincs duplikáció),

• és a legfelső bit automatikusan jelzi a túlcsordulást.

Ez a rendszer annyira logikus, hogy ma minden modern processzor (Intel, AMD, ARM, M1, stb.) ezt használja a negatív számok tárolására.

Érdekesség: a túlcsordulás és a bitvihar

Ha egy szám túlcsordul, azaz túllépi a tárolható tartományt, a gép visszapörgeti a biteket.
Ezt hívjuk overflow-nak.
Például egy 16 bites előjeles számnál: 32767 + 1 -> -32768
Az ember ilyenkor hibát várna, de a processzor „körbeéri” a tartományt — ezért hívják ezt a jelenséget wrap-around-nak.
A szoftverfejlesztők emiatt szoktak külön túlcsordulás-ellenőrzést (overflow check) beépíteni, főleg pénzügyi vagy tudományos számításoknál.

De mit jelent ez pontosan? Hogyan lesz egy színes fotóból, egy hangfájlból vagy egy szövegből bitformátum? És hová kerülnek ezek az adatok – a RAM-ba, az SSD-re, vagy a felhőbe?
Ebben a bejegyzésben lépésről lépésre felfedezzük, hogyan működik az adattárolás és a kódolás a számítógépben, és miért kulcsfontosságú mindez a digitális világunk megértéséhez.

Amikor ma megnyitsz egy programot a laptopodon vagy telefonodon, észre sem veszed, hogy egy több mint 70 éves vita öröksége dolgozik a háttérben. Ez a vita két zseniális iskola között zajlott: a Harvard-elv és a Neumann-elv hívei között.

Harvard-elv — amikor az adat és a program nem keveredik

A Harvard-architektúra a számítástechnika „régi iskolája”. Itt az adat (amit feldolgozunk) és a program (ami feldolgozza) külön memóriában élnek.
Ez olyan, mintha két teljesen külön könyvtárad lenne: az egyikben a receptkönyvek (programok), a másikban az alapanyagok (adatok).
A Harvard-elvet használták a korai mechanikus és elektromechanikus gépek – például a Mark I (Harvard University, 1944). A programokat lyukkártyákon vagy kapcsolótáblákon állították be, és csak a gép kezelője ismerte őket.

👉 Előny: biztonságos, mert a program nem tudja véletlenül „felülírni” az adatokat.
👉 Hátrány: lassú és merev – minden változtatáshoz kézzel kellett újrakábelezni vagy újrakártyázni a rendszert.

Neumann-elv — az igazi forradalom

Aztán jött Neumann János, a magyar zseni, aki 1945-ben megírta az „EDVAC Memorandumot” – és ezzel forradalmasította a számítógép-építést.
A Neumann-elv lényege az volt, hogy az adatot és a programot ugyanabban a memóriában tároljuk, és ugyanúgy, binárisan ábrázoljuk.
Ez az úgynevezett „tárolt program elve” (stored-program concept).

A gép így már önállóan is képes volt a programokat futtatni, nem kellett fizikailag beavatkozni.
Ez tette lehetővé a modern operációs rendszereket, a szoftvereket, sőt, még az AI-t is.

Miért zseniális ez az elv?

• Mert a programok is adatok, tehát a gép önmagát is képes módosítani – például új kódokat tölthet le, frissíthet, futtathat.

• Mert a sebességet már nem a kábelek, hanem az architektúra és a CPU-műveletek határozzák meg.

• Mert ezzel megnyílt az út a magas szintű programozási nyelvek és a komplex szoftverek előtt.

avagy hogyan érti meg a gép, amit mondunk

A számítógép nem beszél nyelveket –  csak két dolgot ismer: 0 és 1. Minden, amit látunk a kijelzőn – szöveg, kép, zene, videó, játék – ezekből a bitekből épül fel.
Ahhoz, hogy a gép ezt értelmezni tudja, szükség volt egy egységes módszerre: ez az adatábrázolás és a kódolás.

​

Miért kellett szabányosítani az adatábrázolást?

Képzeld el, ha minden számítógép másképp értelmezné az „A” betűt. Egyiknél 01000001, a másiknál 11001100 lenne – totális káosz. Ezért hozták létre a szabványos kódrendszereket (ASCII, Unicode, UTF-8), hogy minden gép ugyanúgy tudja: 01000001 = A.
Ez tette lehetővé, hogy az interneten a világ bármelyik gépe ugyanazt az e-mailt, képet vagy karaktert jelenítse meg.

Hogyan működik az adatábrázolás?

Az adatok tárolása és feldolgozása bitek kombinációjával történik.

• A betűk, számok, írásjelek mind külön-külön bitmintát kapnak – ezeket nevezzük karaktereknek.

• Minden karakterhez hozzárendelünk egy szabványos bináris kódot.

• A gép ezeket olvassa, tárolja és továbbítja – innen ered az a szó, hogy kódolás. A gép lefordítja a jeleket a saját nyelvére, vagyis a kódra. (számok, jelek -> bitek)

Két fő adattárolási forma:

(avagy hogyan gondolkodik a számítógép a számokról és karakterekről)

A számítógép nem tud különbséget tenni szám, betű vagy hang között — neki minden bitkombináció.
Az, hogy ebből információ lesz, attól függ, hogyan értelmezi ezeket a biteket. Ez az információábrázolás lényege.

Numerikus információ

A gépekben a számok tárolására többféle módszer létezik — attól függően, hogy mekkora helyet foglalhatnak, és milyen pontosságra van szükség.

1️⃣ Egész típusú számok

• Előjel nélkül: csak pozitív értékek (pl. 0–255 nyolc biten).

• Előjeles: a legnagyobb bit az előjelet jelzi (pozitív vagy negatív).

  • 1-es komplemens: a negatív számok az összes bit invertálásával jönnek létre.

  • 2-es komplemens: a modern gépek ezt használják, mert egyszerűbb a műveletvégzés (pl. -5 = 11111011).

2️⃣ Fixpontos számábrázolás

Itt a tizedespont helye fix, tehát a gép előre tudja, hány bit tartozik az egész, és hány a tört részhez.
Ez gyors, de nem túl rugalmas – például beágyazott rendszerekben (mikrokontrollerekben) gyakori.

3️⃣ Lebegőpontos számábrázolás

A lebegőpontos formátum a „matematikai szuperhős” a gépekben:
a tört pont helye nem fix, hanem „lebeg”, így hatalmas tartományban tárolhatók számok – kicsik és nagyok is.

Ezt az IEEE-754 szabvány rögzíti (pl. float, double).
A lebegőpontos szám három részből áll:

• előjelbit,

• kitevő (exponens) – excess kóddal,

• és mantissza (a szám jelentős része).

💬 Példa:
-4,5 → 1 10000001 00100000000000000000000
(ez 32 biten, IEEE-754 szerint).

Most, hogy tudjuk, hogyan lesz az adatokból értelmezhető információ, ideje belenézni abba, hogyan ábrázolja a számítógép a számokat magukat.
A gép nem tízes számrendszerben gondolkodik, mint mi, hanem kettesben – nullák és egyesek formájában.
Ez a bináris világ az alapja minden számításnak, memóriaműveletnek és logikai döntésnek, amit a processzor végez.

Ahhoz, hogy az emberi és a gépi gondolkodás között hidat építsünk, meg kell ismernünk a különböző számrendszereket – a binárist (2-es), oktálist (8-as), decimálist (10-es) és hexadecimálist (16-os).
Ezek együtt adják meg azt a nyelvet, amin a számítógép számol, kommunikál és adatokat tárol.

A hexadecimális számrendszer (más néven tizenhatos számrendszer) a számok leírásának egy különleges módja, amit főként a digitális technológiában és programozásban használnak.
Míg a tízes számrendszerben 10 különböző számjegyet használunk (0–9), addig itt 16 különböző jel áll rendelkezésre:

👉 Például:

• A₁₆ = 10₁₀

• B₁₆ = 11₁₀

• C₁₆ = 12₁₀

• D₁₆ = 13₁₀

• E₁₆ = 14₁₀

• F₁₆ = 15₁₀

A számítógépek bináris (0 és 1) nyelvet értenek, de a hosszú bináris sorokat nehéz olvasni.
Ezért a fejlesztők a bináris biteket 4-es csoportokba rendezik, és minden 4 bitet egy hexadecimális jeggyel helyettesítenek.
Így sokkal rövidebb és átláthatóbb formában láthatjuk az adatokat.

Például:
Bináris: 1010 1101 0111 → Hexadecimális számrendszerben: AD7
Egy hexadecimális számjegy 4 bitet jelöl. Egy bájt (8 bit) két hexadecimális jeggyel írható le, pl. 11111111₂ = FF₁₆

​

Hol találkozhatsz vele?

• HTML és CSS színekben, pl.: #FF6600 (narancssárga)
• Memóriacímeknél programozásban
• Hibakódoknál, hálózati címeknél (MAC, iPv6)
• Assembler és alacsony szintű nyelvekben

A bináris számrendszer (kettes alapú) csak két számjegyet használ: 0 és 1.
A hexadecimális rendszer (tizenhatos alapú) ezzel szemben 16 különböző jelet tartalmaz (0–9, majd A–F).
A két rendszer közötti kapcsolat nagyon szoros, mert 4 bináris jegy pontosan 1 hexadecimális jegynek felel meg.

✳️ Átváltás menete

1. Írjuk le a bináris számot.

2. Csoportosítsuk a biteket 4-es csoportokba (jobbról balra haladva).
Ha az utolsó csoportban kevesebb mint 4 bit van, egészítsük ki nullákkal a bal szélén.

3. Minden 4 bites csoportot alakítsunk át a megfelelő hexadecimális jelre.

A tízes számrendszert (decimális rendszert) mindenki ismeri: ez a hétköznapi számírás, amit használunk a mindennapokban.
A számítógépek azonban a tizenhatos számrendszert (hexadecimális) is gyakran használják, mert sokkal rövidebben és áttekinthetőbben lehet vele leírni a bináris adatokat.

De hogyan jutunk el a tízes számrendszerből a tizenhatosba? 🤔
Két lépésben:

1. Az egész részt mindig 16-tal osztjuk, és a maradékokat visszafelé olvassuk ki.

2. A tört részt ezzel szemben 16-tal szorozzuk, és a képződő egész részeket egymás után írjuk.

Ez a két módszer együtt teszi lehetővé, hogy bármilyen valós számot hexadecimális formában is fel tudjunk írni.

1. Feladat: 101011110101₂ → ?₁₆

​

​

​

A tízes számrendszerben a kivonást jobbról balra haladva, helyiértékenként végezzük.
Ha a kisebbítendő számjegy nagyobb vagy egyenlő a kivonandóval, egyszerűen elvégezzük a műveletet.
Ha azonban a kivonandó nagyobb, kölcsön kell kérnünk egyet a következő helyiértékről — ezt nevezzük kölcsönvételnek (borrow).

A tízes számrendszerben a helyiértékek 10-es hatványai szerint csökkennek balról jobbra haladva.
Amikor két számot kivonunk, jobbról balra haladunk.
Ha egy adott helyiértéken a kisebbítendő számjegy kisebb, mint a kivonandó számjegy, akkor kölcsönzünk („borrow”) a következő helyiértékből.

A „kölcsönvétel” során az adott helyiértéken 10-et hozzáadunk az aktuális számhoz, a balra lévő helyiértéken pedig 1-gyel csökkentjük az ottani számjegyet.

Ahol a felső szám kisebb az alsónál, ott kölcsönzést végzünk. Az ábra alján a kis nyíl jelzi, honnan „vettünk át” 1-et. Így kapjuk meg helyesen az eredményt: 1815.59

Most, hogy a decimális összeadás menetét már értjük, nézzük, hogyan működik ugyanez a bináris számrendszerben — ahol csak 0 és 1 létezhet.

​

Mi történik pontosan?

1. oszlop (1-es helyiérték)

• Művelet: 0 − 1 → 10 − 1

• Mi történik: A kisebbítendő (felső szám) utolsó bitje 0, a kivonandó (alsó) 1.
  0-ból nem tudunk 1-et kivonni, ezért kölcsön kell kérnünk a bal oldali (2-es helyiértékű) bitből.
  A balról érkező 1 binárisan 10₂-nek felel meg → így a művelet 10 − 1 = 1.

• Leírjuk: 1

• Kölcsönzünk: ✅ Igen, mert a 0-ból nem tudtunk kivonni.

2. oszlop (2-es helyiérték)

• Művelet: (0 − előző kölcsön) − 0 → 10 − 1

• Mi történik: Eredetileg 0 volt ezen a helyen, de az előző oszlopból elvettünk 1-et, így most még kevesebb maradt — gyakorlatilag „−1” állapotban vagyunk.
  Itt is kölcsön kell kérnünk a következő (4-es) helyiértékből.
  A kölcsön után 10 − 1 = 1.

• Leírjuk: 1

• Kölcsönzünk: ✅ Igen, tovább kellett adni.

3. oszlop (4-es helyiérték)

• 0 − 1 → nem megy → kölcsön kell a 8-as helyiértékből

• De! már csökkentett értékkel indult, tehát a végeredmény 0 lesz
  ❌ leírjuk: 0

4. oszlop (8-as helyiérték)

• 0 − 0, de kölcsönzött innen a 4-es → marad −1, ezért újra kölcsön a 16-osból

• 10 − 1 = 1
  ✅ leírjuk: 1

5. oszlop (16-os helyiérték)

• 1 − (kölcsön) = 0
  ✅ leírjuk: 0

1. feladat: 10000₂ − 00101₂

​

​

​

A tízes számrendszer a mindennapok alapja – minden szám, amit leírunk vagy kimondunk, ennek a rendszernek az eleme.
Itt minden helyiérték a tíz hatványaival növekszik:
egyesek, tízesek, százasok, ezresek és így tovább.

Amikor két számot összeadunk, jobbról balra haladunk, mindig az egyesek helyiértékétől kezdve.
Ha az adott oszlopban (helyiértéken) az összeg több mint 9, akkor a „tízeseket” átvisszük (carry) a következő, balra eső helyiértékre.
Ez az átvitel ugyanaz a logika, amit majd a bináris összeadásnál is látni fogunk – csak ott 2 lesz a határ, nem 10.

Példa:

1827.37 + 3642.96 = 5470.33

Lépésenként így működik:

Az utolsó oszlopban: 7 + 6 = 13 → leírjuk a 3-at, és 1-et viszünk át.

A tizedeseknél: 3 + 9 + 1 = 13 → leírjuk a 3-at, viszünk 1-et.

Az egyeseknél: 7 + 2 + 1 = 10 → leírjuk a 0-t, viszünk 1-et.

Tizeseknél 2 + 4 + 1 = 7 → leírjuk a hetet, nem viszünk semmit. 

A százaknál: 8 + 6 = 14 → leírjuk az 4-et, viszünk 1-et a következő oszlopba.

Végül a legbaloldali oszlopban: 1 + 3 + 1 = 5 → leírjuk az 5-öt, már nincs mit továbbvinni.

Így kapjuk meg az eredményt: 5470.33

Most, hogy a decimális összeadás menetét már értjük, nézzük, hogyan működik ugyanez a bináris számrendszerben — ahol csak 0 és 1 létezhet.

Bináris összeadás elmélete

A bináris (kettes) számrendszer alapja a 2, tehát minden helyiérték kétszerese az előzőnek:
1, 2, 4, 8, 16, 32, 64…

Összeadásnál itt is helyiértékenként dolgozunk, de mivel csak 0 és 1 létezik, a lehetséges eredmények nagyon egyszerűek:

​

A kettes számrendszerben csak 0 és 1 van, a „határ” 2.
Ha egy oszlopban az összeg eléri a 2-t, 0-t írunk le és 1-et viszünk tovább (mint tízesnél a 10, csak itt a „bázis” 2).

Haladjunk jobbról balra:
1-es helyiérték: 1 + 1 = 10₂ → leírjuk 0, 1-et visszük a 2-es helyiértékhez.

2-es helyiérték: 1 (carry) + 1 + 0 = 10₂ → leírjuk 0, 1-et visszük a 4-eshez.

4-es helyiérték: 1 (carry) + 0 + 1 = 10₂ → leírjuk 0, 1-et visszük a 8-ashoz.

8-as helyiérték: 1 (carry) + 1 + 1 = 11₂ → leírjuk 1, 1-et visszük a következő (16-os) új helyiértékhez.

A bal szélen az átvitelből létrejön egy új 1-es bit → így kapjuk meg a végeredményt:  11000₂.

1. feladat: 10101₂ + 1110₂

​

​

​

Ebben a leckében megtanuljuk, hogyan lehet decimálisból binárisba átváltani egy számot lépésről lépésre. Megmutatom, miért használják a gépek ezt a rendszert, és hogyan lehet gyorsan átlátni a váltást számológép nélkül is.
Készülj, mert most tényleg belenézünk a számok mögé.

A decimálisból bináris számrendszerbe való átváltás lényege, hogy a számot kettővel osztogatjuk, amíg el nem jutunk a nulláig.
Minden osztásnál megjegyezzük a maradékot — ezekből a maradékokból fog összeállni a bináris szám visszafelé olvasva.

🧮 Példa: alakítsuk át a 25₁₀ számot binárisba

Alapelv 

Szabály: a tört részt (0.xxx) mindig 2-vel szorozzuk, és feljegyezzük az egészrészt (0 vagy 1).
A kapott új tört részt megint 2-vel szorozzuk… és így tovább.
A bináris törtrész a feljegyzett egészrészek sorrendben egymás után.

Példa 1 – 0,625₁₀ → ?₂

1. 0,625×2 = 1,25 → egészrész 1, maradék 0,25
2. 0,25×2 = 0,5 → egészrész 0, maradék 0,5
3. 0,5×2 = 1,0 → egészrész 1, maradék 0 (vége)

Eredmény: 0,101₂

Példa 2 – 0,375₁₀ → ?₂

1. 0,375×2 = 0,75 → egész 0, maradék 0,75
2. 0,75×2 = 1,5 → egész 1, maradék 0,5
3. 0,5×2 = 1,0 → egész 1, maradék 0

Eredmény: 0,011₂

Példa 3 – 0,1₁₀ → ?₂ (végtelen ismétlődés!)

1. 0,1×2=0,2 → 0
2. 0,2×2=0,4 → 0
3, 0,4×2=0,8 → 0
4. 0,8×2=1,6 → 1 (marad 0,6)
5. 0,6×2=1,2 → 1 (0,2)
… és visszajutunk 0,2-hez, tehát ismétlődik.

Eredmény: 0,**0001100110011…**₂ (a „0011” blokk periodikusan ismétlődik)

Vegyes szám 

12,5₁₀ → ?₂
12 → 1100₂, 0,5 → 0,1₂ ⇒ 1100.1₂

​

1. feladat 0,25₁₀ = ?₂

​

​

​