Lebegőpontos típusok és a decimal

1Egészekkel nem megy — a törtvilág

Számoljunk átlagot a B2 eszközeivel:

int jegy1 = 4;
int jegy2 = 5;
Console.WriteLine((jegy1 + jegy2) / 2);   // 4  — pedig 4.5 kellene!

Egész / egész = egész — a 4,5-ből 4 lett. Ide új típus kell: olyan, amely törtrészt is tárol. A C# hármat is ad, és a választás közöttük nem ízlés kérdése.

2A három törttípus

Három dolog, amit rögzíts:

1. A tizedes literál alapból double — a 3.14 önmagában double.
2. Utótag jelöli a másik kettőt: 3.14f → float, 3.14m → decimal (a 3.14d → double, de ezt nem szokás kiírni). Utótag nélkül a float f = 3.14; le sem fordul (CS0664) — a fordító nem hajlandó csendben pontosságot veszíteni.
3. A float és a double neve onnan jön, hogy a tizedespont „lebeg”: a gép a számot egy szorzat alakjában tárolja (számjegyek × 2 valamelyik hatványa), így ugyanaz a típus tud nagyon nagy és nagyon kicsi számot is — de mindig csak korlátos számú értékes jeggyel.

double magassag = 1.72;
float sebesseg = 12.5f;
decimal ar = 2499.90m;

3A nagy meglepetés: 0.1 + 0.2

Írasd ki — a saját gépeden, most:

Console.WriteLine(0.1 + 0.2);     // 0.30000000000000004

Nem elírás, és nem a géped romlott el. A magyarázat: a gép kettes számrendszerben tárol, és ott a 0.1 végtelen szakaszos tört — pontosan úgy, ahogy tízes számrendszerben az 1/3 = 0,33333… sosem írható le véges számjeggyel. A double a 0.1-nek csak egy nagyon jó közelítését tudja eltárolni, és a parányi kerekítési hibák összeadódva néha láthatóvá válnak.

Ez nem bug — ez a lebegőpontos ábrázolás természete, minden nyelvben így van (a JavaScript is ezt csinálja). A kérdés csak az, mikor számít:

• Mérésnél, tudományos számításnál, játék-koordinátánál: nem számít — a 15 értékes jegy mellett a hiba a valóság zajánál is kisebb. → double jó.
• Pénznél: nagyon is számít! Számlán, egyenlegen egyetlen fillér eltérés sem megengedett. → itt jön a decimal.

4A decimal — a pénz típusa

A decimal tízes számrendszerben tárol — pontosan úgy „gondolkodik”, ahogy a papíron számolunk. A 0.1m tényleg pontosan 0.1:

double d = 0.1 + 0.2;
decimal m = 0.1m + 0.2m;

Console.WriteLine(d);     // 0.30000000000000004
Console.WriteLine(m);     // 0.3   — pontosan

Egy valósághű árszámítás — csupa decimal:

decimal nettoAr = 1999.00m;
const decimal AfaSzorzo = 1.27m;      // B1: a bűvös szám konstansba való!

decimal bruttoAr = nettoAr * AfaSzorzo;
Console.WriteLine(bruttoAr);          // 2538.7300

Az ára: a decimal lassabb és kisebb a tartománya (kb. ±7,9 × 10²⁸ — azért ez is bőven elég egy államadósságra). Cserébe 28–29 értékes jegy, tizedesen pontosan.

A döntési szabály

A Mastermindban int-ek lesznek; a kalandjáték boltjában (II. félév) decimal árak.

5Aritmetika és zárójelezés

A műveleti sorrend (precedencia)

A C# ugyanúgy számol, ahogy a matekórán tanultad:

1. zárójel — mindent felülír;
2. *, /, % — szorzás, osztás, maradék;
3. +, - — összeadás, kivonás;
4. azonos szinten balról jobbra.

Console.WriteLine(2 + 3 * 4);     // 14  — előbb a szorzás
Console.WriteLine((2 + 3) * 4);   // 20  — a zárójel felülír
Console.WriteLine(10 - 4 - 3);    // 3   — balról jobbra: (10-4)-3

A klasszikus átlag-csapda:

int jegy1 = 4;
int jegy2 = 5;

Console.WriteLine(jegy1 + jegy2 / 2);     // 6  — ROSSZ: csak a jegy2 feleződött!
Console.WriteLine((jegy1 + jegy2) / 2);   // 4  — jobb, de még egészosztás…

Amikor egész és tört keveredik

És most a B2-es szálka feloldása. Ha egy műveletben az egyik oldal tört, az egész fél automatikusan törtté lép elő, és az eredmény is tört:

Console.WriteLine(7 / 2);       // 3    — int / int = int
Console.WriteLine(7 / 2.0);     // 3.5  — int / double = double!
Console.WriteLine(7.0 / 2);     // 3.5  — ez is

Így már megvan a helyes átlag is:

Console.WriteLine((jegy1 + jegy2) / 2.0);   // 4.5  ✔

6Gyakori hibák

7Gyakorlat — a meglepetéstől a blokkig

1. Új projekt: Console App, név: Tortek, .NET 10.
2. Reprodukáld a meglepetést: írasd ki a 0.1 + 0.2-t double-ként, majd 0.1m + 0.2m-ként. Tegyél töréspontot, és a Locals-ban is nézd meg a két értéket!
3. Bevásárlás-számoló — csupa decimal:

decimal kenyer = 899.50m;
decimal tej = 429.90m;
decimal sajt = 1249.00m;

decimal osszesen = kenyer + tej + sajt;
Console.WriteLine(osszesen);              // 2578.40

4. Bővítsd: az árak bruttók; számold ki a blokk ÁFA-tartalmát (27%-os kulccsal: osszesen - osszesen / 1.27m) — és a 1.27m-et tedd konstansba (B1!).
5. Átlag helyesen: két int jegyből számolj double átlagot a 2.0-trükkel.
6. Commitold (Tort tipusok es aritmetika gyakorlat).

8Feladatok

9Önellenőrző kvíz

10Fogalomtár

11Összegzés