Egész típusok és a túlcsordulás

1Miért nem elég egyetlen számtípus?

A memória rekeszekből (bájtokból) áll, és minden változó annyi rekeszt foglal, amekkora a típusa. Egy bájt 8 bit — 8 darab 0/1 —, ami összesen 2⁸ = 256 különböző értéket tud megkülönböztetni. Több bájt = több bit = nagyobb tartomány:

A kérdés csak az: a rendelkezésre álló értékkészletet hova tesszük a számegyenesen? Ha csak nemnegatív számok kellenek, mehet 0-tól felfelé; ha negatívak is, a készlet fele a nulla alá kerül. Ebből születik a típuscsalád.

2Az egésztípusok családja

Az u előtag (unsigned — előjel nélküli) azt jelenti: ugyanannyi rekesz, máshová tolva. A byte és az sbyte egyaránt 256 értéket tud — csak máshogy osztja be:

A pontos határokat sosem kell fejből tudni — a típus maga megmondja:

Console.WriteLine(int.MaxValue);    // 2147483647
Console.WriteLine(int.MinValue);    // -2147483648
Console.WriteLine(byte.MaxValue);   // 255
Console.WriteLine(long.MaxValue);   // 9223372036854775807

3Melyiket mikor? — az ökölszabály

Alapértelmezés: int. Gyors, kényelmes, a C# minden egész literált eleve int-nek tekint — és ±2,1 milliárd az esetek túlnyomó részére elég.

4Műveletek egészekkel

Az alapműveletek: +, -, *, / — és egy ötödik, amely csak itt, az egészek világában igazán érdekes: a %.

Az egészosztás

Egész osztva egésszel egészet ad — a törtrész nem kerekedik, hanem levágódik:

Console.WriteLine(7 / 2);     // 3   — nem 3.5!
Console.WriteLine(9 / 10);    // 0
Console.WriteLine(100 / 7);   // 14

A maradék (%)

A % (maradékképzés, angolul modulo) azt adja meg, mennyi marad az osztás után:

Console.WriteLine(7 % 2);     // 1
Console.WriteLine(100 % 7);   // 2

A / és a % párban hihetetlenül hasznos — klasszikus példa az átszámítás:

int osszesPerc = 127;

int ora = osszesPerc / 60;    // 2   — hány TELJES óra
int perc = osszesPerc % 60;   // 7   — mennyi marad percben

Console.WriteLine(ora);
Console.WriteLine(perc);

Rövidítések

A „vedd elő, változtasd meg, tedd vissza” minta olyan gyakori, hogy a C# rövid alakot ad rá:

Az a++-t a C blokkban, a ciklusoknál fogod naponta látni — barátkozz vele már most.

5A túlcsordulás — amikor a doboz körbefordul

Mi történik, ha a legnagyobb tárolható értékhez hozzáadunk egyet? A doboz nem tud „kicsit nagyobb lenni” — az érték átfordul a tartomány másik végére, mint a régi kilométeróra 999 999 után:

int szamlalo = int.MaxValue;
Console.WriteLine(szamlalo);      // 2147483647

szamlalo = szamlalo + 1;          // csendben körbefordul!
Console.WriteLine(szamlalo);      // -2147483648

Ez a túlcsordulás (overflow) — és a legveszélyesebb benne, hogy alapbeállításban néma: se hibaüzenet, se kivétel, a program vidáman számol tovább az értelmetlen értékkel.

Mikor szól a fordító, és mikor nem?

Ha a túl nagy érték már a kódban látszik, a fordító elkapja:

byte kicsi = 300;                 // ⛔ CS0031: Constant value '300' cannot
                                  //    be converted to a 'byte'

Ha viszont az érték futás közben csordul túl (mint fent a szamlalo), a fordító nem láthatja előre — az már a te felelősséged.

A checked — védőháló kérésre

A checked blokkon belül a túlcsordulás nem néma többé:

checked
{
    int szamlalo = int.MaxValue;
    szamlalo = szamlalo + 1;      // 💥 OverflowException — a program jelez!
}

A kivételekről (mi ez a 💥, és hogyan kapjuk el) a K blokkban tanulunk — most annyi a lényeg: van mód rá, hogy a néma körbefordulás helyett hangos hibát kérj.

6Gyakori hibák

7Gyakorlat — túlcsordulás a szemed előtt

1. Új projekt: Console App, név: Egeszek, .NET 10.
2. Írasd ki a határokat: int.MaxValue, int.MinValue, byte.MaxValue, long.MaxValue. Nézd meg, tényleg akkorák-e, mint a 2. szakasz táblázatában!
3. Gépeld be a túlcsordulás-példát az 5. szakaszból. Tegyél töréspontot a szamlalo = szamlalo + 1; sorra, és a Locals ablakban (B1!) nézd végig, ahogy a 2147483647-ből −2147483648 lesz. F10 — és megtörtént.
4. Tedd az egészet checked { } blokkba, futtasd újra — most kivételt kapsz. Olvasd el az üzenetét!
5. Írj perc-átszámítót: az osszesPerc = 4321 értékből számold ki /-vel és %-kal, hány óra és hány perc. (Ellenőrzés fejben: 4321 / 60 = 72 óra, marad 1 perc.)
6. Commitold a kész gyakorlatot (Egesz tipusok es tulcsordulas gyakorlat).

8Feladatok

int a = 2147483645;
a += 4;
Console.WriteLine(a);

9Önellenőrző kvíz

10Fogalomtár

11Összegzés