Operátorok. Számábrázolás

Amint az ütemtervben is látható,

jövő héten (5.) elmarad az előadás (09.30.) és a gyakorlat (10.01.) is.

NHF választás hétfőtől elérhető, csak nem lesz előadás, hogy hirdessük...

Operátorok

Operátorok: a kifejezések építőkockái

• Pl. matematikai műveletek jelei: +, -, *, /
• Operandusok: amiken a műveletet végzik

Mik az operandusok? – Szabályok

• Több is lehet: a = -x; unáris (unary), b = x-y; bináris (binary), azaz egy- és kétoperandusú
• Precedencia: különfélék „erőssége”, pl. 5+2*3 = 5+(2*3)
• Asszociativitás: egyformák csoportosítása, pl. a/b/c = (a/b)/c

Az operátorok precedenciája és asszocivitása tehát nem azt határozza meg, hogy egy nagyobb kifejezés melyik részkifejezését értékeli ki időben előbb a program, hanem csak azt mondják meg, hogy melyik operátornak mi az operandusa. Pl. egy a*b+c*d kifejezésben mindegy is, hogy előbb az a*b vagy a c*d részkifejezést értékeljük ki. Ellenben az a/b/c kifejezés egészen mást jelentene, ha az osztás jobbról balra lenne asszociatív, mert akkor a/(b/c)-t értenénk alatta, ami viszont nem ugyanazt az eredményt adja.

Az operátorok által leírt műveletek ún. kifejezésfákkal ábrázolhatóak. A kifejezésfa megadja, hogy melyik operátoroknak mely értékek az operandusai. A kifejezésfa már nem tartalmaz zárójeleket, annak a hierarchiája ugyanis egyértelműen meghatározza, hogy mely művelethez mely operandusok tartoznak. Az alábbi rajzokon sárga színnel jelöltük az operátorokat. Az ezekből lefelé kiinduló vonalak adják meg, hogy az adott operátorhoz mely operandusok tartoznak. A kék szín olyan részkifejezéseket jelöl, amelyek önmagukban kiértékelhetőek; ilyenek a változók és a konstansok. Ezekből már nem indulnak ki vonalak lefelé, nincsenek operandusaik.

3 * x + 8

6 * (y - 4)

a = -b

Előfordulhat az, hogy egy operátor többféleképp működhet?

int a = 5, b = 2;
double c = 5, d = 2;
double x;


x = a / b;
printf("%g\n", x); // 2
x = c / d;
printf("%g\n", x); // 2.5


x = (double)a / b;
x = a / (double)b;
printf("%g\n", x); // 2.5

Polimorfizmus (többalakúság)

Az operátorok jelentése függhet az operandusok típusától:

• a/b: osztás. Ha a és b is int, egész osztás, ami lefelé kerekít!
• Ha bármelyik lebegőpontos, az eredmény is az.

Az egész osztás sok esetben hasznos. Lásd a bankautomatás feladatot: ha az a kérdésünk, hogy 5500 Ft kifizetéséhez hány ezresre van szükségünk. 5500/1000 = 5 darab ezres, és 5500%1000 = 500 Ft a maradék, amelyet máshogy kell megoldanunk, nem ezresekkel.

Ha valamelyik operandus valós, a másik automatikusan valóssá konvertálódik. Automatikus konverzió egyéb esetekben is történik. Pl. short+int összeadás esetén a short típusú operandus a nagyobb ábrázolási tartományú int típusúvá konvertálódik. Ugyanígy, int+long esetén az összeadás előtt az int konvertálódik automatikusan, az 5+2.3 kifejezésben pedig az 5-ből lesz 5.0. Mindig a nagyobb ábrázolási tartomány felé történik az automatikus konverzió, hogy ne amiatt legyen adatvesztés vagy túlcsordulás.

Kézi konverzió (cast)

• Ha két int van, de lebegőpontos osztást szeretnénk, jelezni kell
• Konverziós (cast) operátort használva: (double) x

Fontos megfigyelni, hogy jobb oldalt látható kódban az x=a/b kifejezésben az eredmény még így is 2, hogy utána azt a double x változóba másoljuk! Az értékadás egy újabb operátor, amelynek az osztás eredményébe már nincsen „beleszólása”. Az osztás egész/nem egész jellege nem azon múlik, hogy az elvégzése után mit csinálunk az eredménnyel! Ha az osztás valamelyik operandusát lebegőpontos számmá alakítjuk azáltal, hogy elé a (double) operátort írjuk, már nem egész osztás fog történni. A konverziós operátorok nagyon magas precedenciájúak: mindig közvetlenül arra az értékre vonatkoznak, amelyek elé írjuk őket.

A konverzió segítségével más típusúvá alakítható egy érték. Egy lebegőpontos érték elé (int)-et írva egésszé alakítható az, természetesen a törtrészt elveszítve. Számtani műveletek esetén ritkán kell kézi konverziót alkalmazni. Más típusoknál, a mutatóknál, amelyek egy későbbi előadáson fognak szerepelni, nagyobb szerepet kapnak a konverziók. De ezekről majd később.

A printf() értéke

123, 456, 1234,
0, 6, 12, 11, 1,
1234577, 93628,
2, 4, 9, 1, 3,

A printf() függvény, amellett hogy kiírja a megadott szöveget a képernyőre, megadja a kiírt karakterek számát is. Ez hasznos lehet, ha azt szeretnénk vizsgálni, a sor végére értünk-e már. A jobb oldalon látható dobozban például az egyes sorok nagyjából egyforma hosszúak, függetlenül attól, hogy az egyes számok hány számjegyből állnak. Kicsi számokból sok kifér egy sorba, nagy számokból kevés. A kimenetet ez a programrész generálta:

int db = 0;
for (int i = 0; szamok[i] != -1; i += 1) {
    db += printf("%d, ", szamok[i]); // !
    if (db > 15) {
        printf("\n");
        db = 0;
    }
}

Erre azt mondjuk, hogy a printf() műveletnek van értéke és mellékhatása is. Az érték a kiírt karakterek száma, a mellékhatás pedig a szöveg kiírása. A mellékhatás a programozásban nem jelent rosszat! A printf()-et általában épp a mellékhatása miatt használjuk: a kiírás a lényeges, az értékkel, a karakterek számával ritkán foglalkozunk. De ettől még a kiírás technikailag egy mellékhatásnak számít.

Érték és mellékhatás: példák

Összehasonlításképp:

printf("hello")

sqrt(2)

Érték és mellékhatás

Az operátorok esetén az érték és a mellékhatás fogalmát ugyanígy használjuk.

Lássunk két kifejezést a mellékhatás és az érték megértéséhez.

x + y

x = y

Miért fontos a mellékhatás figyelembe vétele? A mellékhatással nem rendelkező operátorokkal leírt képletek mindig ugyanazt az eredményt adják. Az x+y kifejezésnek nincs mellékhatása, ezért akárhányszor is kiértékeljük, ugyanazt a számot fogjuk kapni. Ezzel szemben, az x+=1 kifejezésnek van mellékhatása: nem ugyanaz lesz az eredmény elsőre, másodjára, harmadjára.

Az értékadás értéke

a = b = 1;
a = (b = 1);         // jobbról balra asszociatív
b = 1; a = 1;

A mellékhatás jelenti a változtatás képességét. Az = operátort a mellékhatása miatt használjuk. Az értékével ritkán törődünk, viszont pont az teszi lehetővé a láncolt értékadást: pl. az a=b=1 kifejezés mindkét változóba 1-et tesz. Így rövidebben, kifejezőbben tudjuk leírni, hogy mindkét változónak ugyanazt az értéket szeretnénk adni.

Hogy működik egy ilyen láncolt értékadás? Az = értékadó operátor jobbról balra asszociatív, tehát az a=b=1 kifejezés pont ugyanúgy működik, mintha a=(b=1) formában zárójeleztük volna. Így már érthető: az 1-es érték a b változóba másolódik (mellékhatás), a b=1 részkifejezés értéke pedig a másolt érték, az 1. Ezt kell helyettesíteni a kifejezésbe a b=1 helyére: a=(1), innen pedig már látszik, hogy az a-ba is 1 kerül.

Az értékadás az egyik legfontosabb operátorunk, mert ezzel tudjuk változtatni a változók értékét a program futása során. Nem minden kifejezés állhat azonban az értékadás bal vagy jobb oldalán: a=1 és szamok[2]=5 helyes, viszont 1=a és a+2=3 helytelen kifejezések. Értéket adni változóknak, tömbelemeknek tudunk: ezeket balértéknek (left, l-value) nevezzük, mert ilyenek állhatnak egy értékadó operátor bal oldalán is. Az értékadó operátor kizárólag jobb oldalára írható értékeket pedig jobbértéknek (right value, r-value) nevezzük. Általában véve a balértékek valamiféle változók szoktak lenni, a memóriában megjelölt helyek; a jobbértékek pedig számértékek, számítások eredményei, amik nem kötődnek helyhez.

A balérték, jobbérték kifejezéseket ismerni kell, mert a fordítók hibaüzeneteiben gyakran megjelennek. Például az 5=6 kifejezésre az „lvalue required as left operand of assignment” jelzést kapjuk, vagyis hogy az értékadás bal oldali operandusaként egy balérték kellene szerepeljen.

Mindezek érvényesek az összes kombinált értékadó operátorra is: +=, -= stb.

printf("%d", a = b); // neeeee
a = b;
printf("%d", a);

Az értékadás kifejezés értéke miatt olyanokat is lehet írni, mint a fenti printf – de nem érdemes. Az ilyesmi csak zavart okoz. Bár a fordító által készített gépi kód úgyis teljesen ugyanaz lesz, inkább kerüljük a felesleges tömörítést! Jobb külön, két sorba leírni a két, egymástól logikailag független teendőt (értékadás, kiírás).

Rövidített értékadások

x = x + 1;
x += 1;

y = y / 5;
y /= 5;

Mint láttuk, az összes aritmetikai művelet rövidítve is leírható, ha egy változóból kiolvasott adattal szeretnénk dolgozni, és visszaírni az eredményt ugyanabba a változóba. Így lesz az x = x+1-ből x += 1, és az y = y/5-ből y /= 5.

A ++ és -- operátorok

int i = 5;
++i;
printf("%d", i); // 6

int j = 5;
--j;
printf("%d", j); // 4

Egy változó eggyel növelése és csökkentése nagyon gyakori művelet. Leginkább ciklusokban és tömböknél használjük őket: következő lépés, előző elem, és így tovább. Emiatt ezekhez egy még rövidebb formát kitaláltak, külön operátorokkal jelölhető a „növeld meg eggyel a változót”, és „csökkentsd le eggyel a változót”. Vagyis az „ugorj a következő elemre”, és „lépj vissza az előző elemre”. Ezek az operátorok ++ és --, az ún. inkremens (increment) és dekremens (decrement) operátorok.

#include <stdio.h>

int main(void) {
    int x = 3;
    int y = ++x;
    printf("x = %d, y = %d", x, y);
    
    printf("\n\n");

    int a = 3;
    int b = a++;
    printf("a = %d, b = %d", a, b);

    return 0;
}

x = 4  y = 4

a = 4  b = 3

Ciklusban vagy önmagában

for (int i = 1; i <= 10; ++i) {
   /* ... */
}

Nem használjuk az értékét. Itt teljesen mindegy, melyik változatot írjuk, az i++ vagy a ++i alakot.

for (int i = 1; i <= 10; i++) // ugyanaz, mint a fenti
    printf("%d ", i);

Tömb feltöltése

scanf("%d", &x);
szamok[db++] = x;

Itt a posztfix formát használjuk. A darabszám régi értéke az index; oda beírjuk, utána növeljük. Pl. ha db = 2, az új elem szamok[2] helyre kerül, utána db = 3 lesz. Ami pont stimmel, hiszen az 5 elem a szamok[0]…szamok[4] helyeken van.

A mellékhatások kiértékelési pontokig (sequence point) érvényesülnek.

• Utasítás végén: ; vagy }
• if, while, for feltétele után
• Néhány operátornál menet közben: logikai és vessző
• Függvényhívás előtt az összes paraméter kiértékelődik

„A szabvány által nem definiált”

• A kiértékelési pontok között a mellékhatások sorrendje kötetlen!
• A függvényparaméterek kiértékelési sorrendje kötetlen
• Ha kell, több utasításba szedéssel, segédváltozók használatával kényszeríthetjük a sorrendet.
• Helytelen: a = a++;
• Viszont helyes: while (scanf("%c", &c) == 1 && c != '\n')

A „3 operandusú operátor” (ternary operator)

• Formája: feltétel ? igaz_kif : hamis_kif
• Értéke: ha IGAZ a feltétel, igaz_kif, különben hamis_kif értéke.
  Mint Excel-ben a HA() függvény.

Ezt az operátort kérdőjel–kettőspont operátornak, vagy feltételes operátornak szokás nevezni. Néha, főleg angol nyelvű szakirodalomban három operandusú operátornak is nevezik, mivel ez az egyetlen, amelyiknek három operandusa van.

Használata

Melyik a nagyobb?

nagyobb = a > b ? a : b;

if (a > b)
    nagyobb = a;
else
    nagyobb = b;

Páros vagy páratlan?

int x;
scanf("%d", &x);
printf("%s", x % 2 == 0 ? "páros" : "páratlan");

Itt a "páros" és "páratlan" sztringek közül választjuk ki az egyiket, a szám paritásától függően. A printf() függvény a formátumsztringen túl már csak egyetlen egy sztringet kap.

A logikai &&, || rövidzár tulajdonsága

if (b != 0 && a/b > 3) // elkerüljük a 0-val osztást
   /* ... */;

if (i < meret && tomb[i] > 0) // túlindexelés elkerülése
   /* ... */;

Gondoljunk egy pillanatra az ÉS, illetve a VAGY műveletek igazságtáblájára. Az alábbiakat mondhatjuk:

• A && B: ha A=HAMIS, nem számít B, az egész biztosan HAMIS
• A || B: ha A=IGAZ, a kifejezés értéke biztosan IGAZ

A nyelv ÉS, illetve VAGY operátorai ezt figyelembe is veszik. Ha az első operandusból kiderül az eredmény, a második operandus már ki sem értékelődik. Bár matematikailag ez a két művelet kommutatív, a programozásban emiatt mégsem mindegy, hogy milyen sorrendben írjuk az operandusaikat.

A rövidzár tulajdonságot a fenti kódrészletekben ki is használjuk – lásd a kommenteket.

A ?: operátor rövidzár tulajdonsága

z = x > y ? x++ : y++;     // neeee

A rövidzár tulajdonság olykor hasznos, de mellékhatásokkal kombinálva veszélyes, mert áttekinthetetlen, érthetetlen programokhoz vezet. Ilyen a fenti is. Első ránézésre úgy tűnik, hogy mindkét változó értéke megnő eggyel. De ez nem igaz, hanem a kettő közül csak a nagyobbik fog nőni, mert x>y esetén csak az x++, amúgy csak az y++ kifejezés értékelődik ki, és csak annak a mellékhatása történik meg. Lehetőleg kerüljük az ilyesmit, ne írjunk ilyeneket! Ne használjunk olyan kifejezést a rövidzár tulajdonsággal rendelkező operátorok operandusaként, amelynek mellékhatása van!

Több kifejezés egymás utáni kiértékelése egy kifejezésben; értéke az utolsó kifejezés értéke. Leggyakrabban for ciklus fejlécében:

for (unsigned i = 0, j = 1; i < 4; ++i, j *= 2)
    printf("Kettő %u. hatványa: %u\n", i, j);

Kettő 0. hatványa: 1
Kettő 1. hatványa: 2
Kettő 2. hatványa: 4
Kettő 3. hatványa: 8

Vigyázat, függvényhívás paraméterei: az nem vessző operátor!

while (oszto < szam, !vanoszto) {   // HIBÁS!
    ...
}

#include <stdio.h>

int main(void) {
    /* 1. */
    printf("%d %d\n",
           printf("hello,\n"),
           printf("vilag\n"));

    /* 2. */
    double a = 2, b = 3, c = 5;
    printf("%f",  a
                 ---
                 b+c
          );

    return 0;
}

int h = printf("hello,\n");
int v = printf("vilag\n");
printf("%d %d\n", h, v);

int kisebbitendo = beolvas();
int kivonando = beolvas();
printf("Különbség: %d", kisebbitendo - kivonando);

Számítógép, számábrázolás, számrendszerek

Memória működése: számok tárolása

Ez tárolja az adatokat és a programokat.

• Karakterek → számok
• Képek → fényesség értékek → számok
• Hang → levegőnyomás értékek → számok
• Gépi utasítások (mov, add) → számok

Érdekesség: A végrehajtott program, és az adatok, amelyeken a program dolgozik, lehetnek külön memóriában is. Az első automatikusan működő számítógépek a programot nem a belső memóriájukban tárolták, hanem papírszalagról vagy lyukkártyáról olvasták be azt futás közben. Ennek egyszerűen az volt az oka, hogy nagyon költséges és bonyolult volt relékből (lásd lent) memóriát csinálni. A tervezők pedig ott spóroltak, ahol tudtak.

Ahogyan a technika fejlődött, úgy vált lehetővé, hogy a programot is a központi memóriában tárolják. Ezt az elvet Neumann János (John von Neumann) javasolta kollégáival, és ma Neumann-féle architektúrának nevezzük. Az első ilyen elven működő számítógép az EDVAC nevet viselte. Ez egyben az első kettes számrendszert használó, már nem elektromechanikus, hanem teljesen elektronikus számítógép is volt. A külön programmemória elve a fentiek ellenére nem halt ki: ezt ma Harvard architektúrának nevezzük, az EDVAC-nál régebbi Mark I számítógép nyomán.

CPU működése

Processzor, CPU (central processing unit): Ez hajtja végre a fordító által gépi kóddá alakított programjainkat.

• Elemi, egyszerű lépések: gépi utasítások
• A fordítóprogram állítja elő a C forráskódból

x += 2;

mov  eax, [1055]  ; x memóriából processzorba
add  eax, 2       ; processzor hozzáad 2-t
mov  [1055], eax  ; eredmény memóriába

A számítógép processzora rendkívül egyszerű, gépi nyelvű utasításokat tud csak végrehajtani. A gépi nyelvnél legtöbbször még egy egyszerű változónövelést is három lépésre kell bontani: 1. a változó értékének kiolvasása a memóriából, 2. az érték növelése, 3. az érték visszaírása a memóriába. A processzor a működés közben így legtöbbet a memóriával kommunikál, jóval többet, mint bármelyik perifériával. Főleg, hogy általában a számítógépeknek közös memóriájuk van az adatok és programok számára.

A római számokkal bizonyos műveleteket, pl. az összeadást nagyon könnyű elvégezni: pl. III + VIII = VIIIIII = VVI = XI. Más műveletek, a szorzás és az osztás bonyolultak. A matematikusok nagy találmánya a nullás számjegy: ez teszi lehetővé azt, hogy tömören (kevés számjeggyel), ugyanakkor helyiértékenként egységes jelölésrendszerrel tudjuk leírni a számokat. A nullás számjegy a leírt számokban helyőrzőként szerepel: a 203 számban pl. azt jelzi, hogy az 2-es a százasok számát tárolja. A hindu-arab számírásban nincs külön jele az egynek, tíznek, száznak, ezernek. (Vegyük észre: a tízes csoportosítás ettől független! A római számokban is létezik már az 1-10-100-1000 fogalma. Nem a tízes csoportosítás a lényeg, hanem a jelölésmód, ami a nulla bevezetésével válik lehetővé.)

A mindennapi életben a tízes számrendszert használjuk. Ebben az egyes helyiértékek a 10 hatványait követik. Ennek oka nagyon egyszerű: azért alakult így ki, mert tíz ujjunk van. Más számrendszerek is használhatóak, és a hindu-arab számírás logikus felépítése miatt ezekben a szabályok pontosan ugyanazok, mint a tízes számrendszerben.

1

1

1

A létező legegyszerűbb számrendszer a kettes alapú. Ebben csak kétféle számjegy van, a 0 és az 1. Hogy miért ez a legegyszerűbb? Mert ebben az összeadó és a szorzótábla nem tízszer tízes, hanem mindössze kétszer kettes.

bináris összeadás

+	0	1
0	0	1
1	1	10

bináris szorzás

×	0	1
0	0	0
1	0	1

Érdekesség: kapcsolók generációi

A mai számítógépek digitális elven működnek. Csak egész számokkal tudnak dolgozni, amelyeket kettes számrendszerben tárolnak. A kettes számrendszer előnye az, hogy csak két számjegy van benne: 0 és 1. Ez elektronikusan könnyen kezelhető (nincs áram, van áram), ezért a működést kapcsolók adják. Bármi, ami kapcsolóként tud működni, az használható számítógép építésére is.

Az alábbi fényképek a számítógépek generációit mutatják. Ezek elvben nem különböznek egymástól, csak a gyakorlatban, méghozzá abból az egyetlen szempontból, hogy milyen elektronikus, vagy esetleg még elektromechanikus eszközt használtak kapcsolónak. Az első három képen lévő eszköz egyetlen kapcsolónak felel meg, míg a jobb alsó képen látható integrált áramkörön már sok millió kapcsoló van. Összehasonlításképp: 3-4000 kapcsoló használatával már egészen jól használható processzor tervezhető, egy Core i7 processzorban viszont már több milliárd darab van.

Relék (relay): az áram hatására a bennük lévő tekercsben (jobb oldalt) mágneses tér keletkezik, és így lehet vezérelni a kapcsolót (bal oldalt). Egy ilyen eszköz kb. 3-4 cm nagy. Manapság is használnak ilyet nagyobb áramok kapcsolására, pl. autókban is.

Elektroncső (tube): a bennük lévő vákuumban repülő elektronok mozgása vezérelhető az elektromos tér változtatásával. Ezek is viszonylag nagyok: 3-4 cm, ráadásul fűteni kell a belsejüket, hogy az elektronok kilépjenek a fémből.

Tranzisztor (transistor): a félvezető anyagok vezetőképessége (ellenállása) elektromos úton szabályozható, így kapcsolónak is használhatóak. A képen látható tranzisztorban a félvezető szilícium darabka 1 mm-nél is kisebb. A védő fém vagy műanyag tokozás nagyobb, 3-4 mm-es.

Integrált áramkör (integrated circuit): ebben is tranzisztorok vannak, azonban az előzőnél jóval kisebbek. Egy 1 cm² méretű szilícium lapra akár több tízmillió transzisztor integrálható, amelyek egyesével alig néhány tíz nanométeresek (vagyis méretük egy ember hajszál vastagságának ezrede). A fenti processzor mikroszkóp alatt forgatva egy videón is látható.

A számrendszerek közötti átalakítás könnyű: csak el kell osztanunk (vagy meg kell szoroznunk) a számokat, számjegyeket az adott számrendszer alapszámának hatványaival.

Átalakítás kettesből tízesbe

Az átalakítás lépései: a szám számjegyeit (alaki értékek) összeszorozzuk kettő megfelelő hatványaival (helyi értékek). Az így kapott számok (valódi értékek) összege adja az eredményt.

Átalakítás tízesből kettesbe

Az átalakítás lépései: a számot leosztjuk kettő első olyan hatványával, amely kisebb nála. Az eredmény egy számjegy, a maradékot pedig felírjuk a következő oszlopba. Így folytatjuk az egyre kisebb hatványokkal, amíg el nem érünk 0-ig. (A legutolsó esetben eggyel osztunk, aminek a maradéka biztosan nulla lesz.) Az osztások során sehol nem kaphatunk 1-nél nagyobb értéket; ha ilyen történne, akkor kettő egy nagyobb hatványától kell indulnunk.

A más számrendszerekbe átalakítás ugyanígy működik, csak az ottani alap hatványait kell használni.

Bitek és bitcsoportok

bit

Az információ alapegysége: 0 vagy 1.

bájt (byte): a memória (adatkezelés) egysége

Jellemzően 8 bites csoport.

szó (word): több bájtos adategység

Általában 4 bájt (32 bit), vagy 8 bájt (64 bit).

Előtagok (prefix)

A kettes számrendszerbeli működés miatt a szokásos mértékegységeknek megvan a bináris párja. Bár a kilo- előtag általában ezret jelent, a számítástechnikában inkább 1024-et, azaz 2¹⁰-t. Ezt azért választották meg így, mert a kettő között nagyon kicsi a különbség. Sajnos gyakran keverik is a kettőt. A merevlemezgyártók például előszeretettel használják a kilo=1000 jelölést, mert így nagyobb kapacitást írhatnak rá az eladott merevlemezekre. Hogy ne kelljen mindig hozzátenni, ha pontosak akarunk lenni, hogy a bináris vagy a decimális prefixumról beszélünk, bevezették a kibibájt, mebibájt stb. jelöléseket. Egy DVD kapacitása így 4,7 gigabájt, azaz 4,3 gibibájt.

kilobájt (kB) és kibibájt (KiB)

10³=1000 ≈ 2¹⁰=1024 bájt.

megabájt (MB) és mebibájt (MiB)

10⁶=1000000 ≈ 2²⁰=1048576 bájt.

gigabájt (GB, GiB), terabájt (TB, TiB)

10⁹≈2³⁰ és 10¹²≈2⁴⁰ bájt.

Érdekesség: A „binary digit”, azaz bináris számjegy szókapcsolatot eredetileg „bigit” vagy „binit” néven rövidítették. Később a „bit” szót John Tukey, amerikai matematikus javasolta. (Ő találta ki a „software” szót is.) A bit szó tudományos írásban először Claude Shannon 1948-as cikkében szerepelt, amelynek címe A Mathematical Theory of Communication. Egy évvel később könyvben is publikálták, de felismerve a cikk egyedülálló gondolatainak általánosságát, a címben a határozatlan névelőt határozottra cserélték. Shannon már korábban, 1937-ben a diplomamunkájában, amelynek címe A Symbolic Analysis of Relay and Switching Circuits megmutatta, hogy az addig telefonközpontokban használt relék segítségével logikai problémák is megoldhatóak. Pár évvel később megépült az első relékből felépített, kettes számrendszert használó számítógép, a Harvard Mark I. Azóta gyakorlatilag nem készül olyan számítógép, amely nem bináris elven működne.

Mivel a számítógép nem végtelen nagy, a tárolt adatok sem lehetnek azok. Ha szeretnénk egy számot eltárolni, akkor arra egy véges, fix méretű memóriaterületet kell kijelölnünk. Ezáltal keletkezik „legkisebb” és „legnagyobb” szám, bár matematikailag ez értelmetlenül hangzik. A számítógépen használt számok emiatt a matematikai számfogalomnak csak tökéletlen modelljei. A matematika számai lehetnek egészek, racionálisak, irracionálisak – a programjainkban ezzel szemben rögzítenünk kell, hogy egy változó típusa egész-e vagy nem, sőt még a tartományban és a pontosságban is be vagyunk korlátozva.

Literálisok: 123, 123u, 123l (123L), 012, 0xFCE2

signed long a;
short b;        /* signed short */
unsigned c;     /* unsigned int */

 11111111

+00000001
─────────
100000000

#include <stdio.h>

int main(void) {
    unsigned char kicsi;
    
    kicsi = 1;
    for (int i = 0; i < 20; i += 1) {
        printf("%u\n", kicsi);
        kicsi *= 2;
    }
    
    return 0;
}

Típusok, amelyekkel érdemes kipróbálni a fenti programot: unsigned char, signed char, short. Bármekkorával is próbáljuk, előbb-utóbb előjön a probléma. Ha kettővel szorozgatjuk a számot, akkor előbb-utóbb nulla lesz az eredmény, így könnyű tetten érni a hibát. Ha hárommal szorzunk a ciklusban, akkor már kevésbé!

Mivel a digitális elven működő hardver csak egész számokkal képes dolgozni, a törtek tárolását vissza kell vezetni egész számokra. Ez megoldható egy normálalakszerű sémával, ahol a kitevő lehet negatív is. A normálalak természetesen a gép (és a tervezőmérnökök) kényelme érdekében nem tízes, hanem kettes alapú.

Lebegőpontos ábrázolás (floating point): lényegében normálalak, kettes számrendszerben:

± mantissza · 2karakterisztika

• Pl. 4 = 1·2² = 100_kettő, ¼ = 1·2^-2 = 0.01_kettő
• Véges a méret: adott bitszám a mantisszának és a kitevőnek
• Korlátos az ábrázolható számtartomány és a pontosság is

a    10000000000000.0000000
b   +             0.0000001
    ───────────────────────
a+b  10000000000000.0000001 → 10000000000000 lesz!

Ha valós szám kell, legtöbbször double-t használunk. A támogatott típusok itt is eltérnek számítógépenként. A long double gyakran nem létezik, hanem a double szinonímája csak. Figyeljünk arra is, hogy a printf()-nek és a scanf()-nek adott formátumkód a double esetében nem ugyanaz. A kiíráshoz ennél %f kell, a beolvasáshoz %lf. (Ennek mélyebb, történelmi okai vannak, amelyek itt nem lényegesek. Némelyik környezettel működik a %lf is, de inkább a %f-et használjuk a printf()-nél!)

A lebegőpontos literálisok típusa is jelezhető: míg 12.3 típusa double, egy f betűt mögé írva, 12.3f esetén float lesz a típus. Használhatunk normálalakot is, mérnöki jelölésmóddal: 6.022e23 = 6,022·10²³. Ugyanígy, 1e40 = 10⁴⁰. A math.h függvényeinek is megvan mind a float paraméterű és értékű párja, pl. sqrtf, sinf, powf és így tovább. Ezeket akkor érdemes használni, ha konzekvensek vagyunk.

A valós értékek véges pontosságú ábrázolása következtében a relációs operátorok használata nem várt viselkedést eredményezhet. Ezért ilyen hasonlításokban ne használjuk azokat a két érték vizsgálatára úgy, ahogyan egészekre tennénk.

eps értékét az elvárt pontosság szerint válasszuk meg, figyelembe véve a típus pontosságát is. Általános esetben double típushoz 10^-10, float esetén 10^-5 pontosság megfelelő. Sokszor − főleg nagy (>1000), vagy kicsi (<0.001) értékeknél − az abszolút pontosság nem felel meg a célra, relatív pontosságot használunk. A hasonlításban szereplő mindkét értéket elosztjuk egyikük (nem lehet nulla) abszolút értékével: fabs( x/fabs(x) - y/fabs(x) ) < eps

Néhány példa a valós számábrázolás pontatlanságaira:

#include <stdio.h>

int main(void) {
    if (0.1 + 0.2 == 0.3)
        printf("Egyenlőek!\n");
    else
        printf("Nem egyenlőek!\n");
    printf("\n");

    printf("%.16f\n", 9.95);
    printf("\n");

    double x;
    for (x = 0; x < 1; x += 0.1)
        printf("%f\n", x);
    printf("\n");

    return 0;
}

Bitműveletek

A legfontosabb, a C nyelvben is megjelenő műveletek a következők.

NEM
(NOT)

A	A
0	1
1	0

ÉS
(AND)

A	B	AB
0	0	0
0	1	0
1	0	0
1	1	1

VAGY
(OR)

A	B	A+B
0	0	0
0	1	1
1	0	1
1	1	1

KIZÁRÓ VAGY
(XOR)

A	B	A⊕B
0	0	0
0	1	1
1	0	1
1	1	0

A léptető operátorok egy szám bitjeit eltolják.

10000110  előtte
00110000  balra 3-mal

x = 134 << 3;

01010110 előtte
00010101 jobbra 2-vel

x = 86 >> 2;

Feladat: írjuk ki 2 hatványait!

for (int i = 0; i < 32; ++i)
    printf("%2d. %10u\n", i, 1U << i);

A formátumsztringben "%10u", mert unsigned, előjel nélküli számot írunk ki. A paraméterben pedig 1U, mert az 1-et unsigned int-nek kell tekinteni, nem pedig int-nek. Különben a 31-edik léptetés már túlcsordulna, az előjelbitbe csúszna az 1-es.

A VAGY operátor | két szám bitjeit hozza VAGY kapcsolatba páronként. Ez minden helyiértéken így lesz, vagyis az egyik szám 0. bitje és a másik szám 0. bitje, az egyik szám 1. bitje és a másik szám 1. bitje, és így tovább.

A VAGY műveletnél az eredmény 1, ha bármelyik 1. Ezt adott bitek 1-be állítására szokás használni. Figyeljük meg: ha az A = 0 bemenetet választjuk, akkor a kimeneten a B értéke jelenik meg. Ha az A = 1-et, akkor pedig fixen 1 a kimenet. Tehát a VAGY művelet lemásolja az egyik bemenetét, ha a másik 0, és fixen 1-et ad a tőle függetlenül, ha a másik 1.

Feladat: állítsuk egy szám 5. bitjét 1-be!

• Olyan maszk (mask) kell, amiben az 5. bit 1-es, többi 0.
• Ez a szám az 1<<5:
  00000001 1
00100000 1<<5
  
• x = x | 1<<5 vagy egyszerűbben: x |= 1<<5

A kizáró vagy ^ két operandusának ugyanolyan sorszámú bitjeit hozza KIZÁRÓ VAGY kapcsolatba. Mivel a KIZÁRÓ VAGY műveletnél az eredmény akkor 0, ha egyformák a bemeneti bitek, és akkor 1, ha nem egyformák, ezt adott bitek negálására szokás használni. Digites terminológiában: a KIZÁRÓ VAGY kapu a vezérelhető (ki/bekapcsolható) inverter.

Feladat: negáljuk egy szám 3. és 4. bitjét!

• A maszk: 1<<3 | 1<<4
• Tehát: x = x ^ (1<<3 | 1<<4)
• Vagy másképpen: x = x ^ 1<<3 ^ 1<<4

Az x = x^y kifejezés rövidítve is írható: x ^= y, vagyis a fenti példa rövid változata: x ^= 1<<3 | 1<<4.

Az & operátor két operandusának ugyanolyan sorszámú bitjeit hozza ÉS kapcsolatba. Ezzel meg tudunk vizsgálni, ki tudunk vágni egy adott bitet egy számból. Miért? Mert ennél a műveletnél ha az egyik bemenet 0, akkor a másik bemenet értékétől függetlenül 0-t ad a kimeneten. Ha az előbbi bemenet 1-es, akkor viszont az utóbbit lemásolja, változatlanul megjeleníti a kimeneten. Olyan, mintha az egyik bemenet 0 értékével letiltanánk a másikat.

Feladat: ellenőrizzük, egyes-e a szám 3. bitje!

• Vágjuk ki csak azt a bitet, minden másikat nullázva
• A maszk: 1<<3
• Tehát: if ((x & 1<<3) != 0) …

A zárójelezés a műveletek erőssége (precedenciája) miatt szükséges. Különben 1<<(3!=0)-t jelentene a kifejezés jobb oldala.

A ~ operátor a bitenkénti negálás jele C-ben. Ezt egy szám vagy változó neve elé írva olyan számot kapunk, amelyben minden bit ellenkezőjére (negáltjára) változik.

Az ÉS művelettel együtt ezt arra is használhatjuk, hogy egy adott szám valamelyik bitjét 0-ba állítsuk. Ennek segítségével lehet ugyanis könnyedén előállítani olyan maszkot, ami csupa 1-esből áll, csak egy megadott helyen van benne 0-s bit. Ezzel az 1-esek helyén „engedélyezzük”, a 0 helyén pedig „letiltjuk” a bitet.

Feladat: állítsuk egy szám 3. bitjét 0-ba!

• Maszk, amelyben csak a 3. bit 0: ~(1<<3), mert:
  00000001 = 1
00001000 = 1<<3
11110111 = ~(1<<3)
  
• Tehát: x = x & ~(1<<3) vagy rövidebben: x &= ~(1<<3)

Ezt a példát a gyakorlat szitás feladatának megoldása után érdemes megnézni!

Egy bájtban, amennyiben az 8 bites, 8 logikai értéket lehet tárolni. Írjuk meg a gyakorlat „Eratoszthenész szitája” feladatát úgy, hogy egy unsigned char típusba tömörítse 8 egymás melletti szám prím/nem prím tulajdonságát – azaz csökkentsük nyolcadára az ottani program memóriahasználatát!

Ebben a programban 8000-ig fogjuk vizsgálni a prímszámokat. A létrehozott tömb most bool prim[8000] helyett unsigned char prim[1000] típusú. Az eredeti változatban 8000 logikai érték (bool) volt; most 8 logikai értéket, bitet sűrítünk egy bájtba (unsigned char), és így a tömbnek már csak 1000 eleműnek kell lennie. Mindegyik logikai érték megtalálható ebben a tömbben, valahányadik bájt valahányadik bitjeként. Mivel minden bájt 8 bitből épül fel, egy vizsgálandó sz sorszámhoz a bájt sorszámát az sz/8 kifejezéssel kaphatjuk meg. Azon belül a bit sorszámát pedig az sz%8 kifejezés adja.

#include <stdio.h>

int main(void) {
    unsigned char prim[1000];   // 8000 bit
    for (int sz = 0; sz < 1000; sz++)   // csupa 1
        prim[sz] = ~0;
    for (int sz = 2; sz < 8000; sz++)
        if ((prim[sz/8] & 1<<(sz%8)) != 0)
            for (int t = sz * 2; t < 8000; t += sz)
                prim[t/8] &= ~(1<<(t%8));   // 0: összetett
    for (int sz = 2; sz < 8000; sz++)
        if ((prim[sz/8] & 1<<(sz%8)) != 0)  // hol maradt 1?
            printf("%8d", sz);
}

    printf("\n");
    for (int n = 0; n < 10; ++n) {
        for (int b = 0; b < 8; ++b)
            printf("%d", (prim[n] >> b) & 1);
        printf("\n");
    }

11110101
00010100
01010001
00000101
00000100
01010001
00000100
00010100
00010001
01000001