c++ alapok
C++ operátorok és kifejezések
Eddig már megtanultuk, hogyan tároljunk értéket változókban – most pedig megtanuljuk, hogyan számoljunk velük!
A C++ igazi ereje abban rejlik, hogy a memóriában tárolt értékekkel műveleteket tudunk végezni: összeadni, kivonni, osztani, hasonlítani, logikai döntéseket hozni.
Mielőtt komolyabb programokat írunk, fontos megérteni, hogyan működnek a kifejezések és az operátorok. Ezek azok az éptőkockák, amikből a programod döntései, számításai és feltételei felépülnek.
Literál és operandus
Minden kifejezés értékekkel és műveleti jelekkel dolgozik. Egy literál az a konkrét érték, amit leírsz a kódban
| Literál típusa | Példa | Jelentés |
|---|---|---|
| Szám literál | 5, -8, 3.14, 5e8 | Egész, negatív, tizedes és normál alakban írt számok |
| Karakter literál | ‘a’ | Egyetlen karakter (ASCII-ban tárolva) |
| Szöveg (string) literál | „szia” | Karakterek sora (string típus) |
| Logikai literál | true, false | Igaz vagy hamis érték |
Ezeket a literálokat vagy változókat kötjük össze operátorokkal – így jön létre a kifejezés (expression). Operandusoknak nevezzük azokat az elemeket, amiken az operátor dolgozik. Például az a + b kifejezésben a és b operandusok,a + pedig az operátor.
Mi az a kifejezés?
Kifejezésnek (expression) nevezünk bármilyen olyan C++ részt, amelynek van értéke. Például: 3 + 4, x * x, a+b/2.
Minden kifejezés valamit kiszámít, és az eredményt, értéket adja vissza.
Mi az az operátor?
Az operátor egy műveleti jel amely két vagy több operanduson dolgozik. Például? +, -, *, /, %
Ezeket matekból már ismered – csak itt a számítógép hajtja végre őket.
A C++-ban többféle operátor van:
Aritmetikai (matematikai) operátor
| Operátor | Jelentése | Példa | Eredmény |
|---|---|---|---|
| + | összeadás | a + b | 5 + 8 = 13 |
| – | kivonás | a – b | 8 – 5 = 3 |
| * | szorzás | a * b | 5 * 8 = 40 |
| / | osztás | a / b | 5 / 8 = 0 (egész osztás) |
| % | maradékos osztás | a % b | 10 % 8 = 2 |
Ezeket a kifejezéseket már tanultad, amit azonban érdemes kiemelni: ha a és b egész típusú, akkor az osztás eredménye is egész lesz. Ezt megnéztük a változóknál bővebben, de mutatom, mire számíthatsz ilyen esetben:
Ha ezt beírod, az eredmény 0 lesz, mert az egész számok halmazán az 5-ben a 8 nullaszor van meg. Ahhoz, hogy pontosabb, tizedes eredményt kapj, az int helyett lebegőpontos típust kell használnod, például float-ot:
Ami esetleg új lehet, az % – maradékos osztás. Ez egész számokkal működik és az osztás maradékát adja vissza.
Műveleti sorrend (operator precedence)
Ahogy a matekban is, itt is van műveleti prioritás. A szorzás és az osztás előrébb van, mint az összeadás és a kivonás. De lényegesen több operátort használunk, ezért több műveleti sorrendre is figyelni kell. A teljes műveleti sorrendet (precedence és associativity) itt találod:
🔗 cppreference.com – Operator precedence
Az asszociativitás azt mondja meg, hogy balról jobbra vagy jobbról balra értékelődik-e a művelet.
Ha felül akarod bírálni, itt is zárójeleket kell használni:
x = 5 + 3 * 2 -> x = 11
x = (5 + 3) * 2 -> x = 16
Összehasonlító (comparison) operátorok
| Operátor | Jelentése | Példa | Eredmény |
|---|---|---|---|
| == | egyenlő | 8 == 10 | false |
| != | nem egyenlő | 8 != 10 | true |
| < | kisebb mint | 3 < 8 | true |
| > | nagyobb mint | 10 > 8 | true |
| <= | kisebb vagy egyenlő | 5 <= 5 | true |
| >= | nagyobb vagy egyenlő | 7 >= 8 | false |
A true = 1, a false pedig = 0-ként jelenik meg. Itt érdemes azt is megjegyezni, hogy a << kiíratás jele is egy operátor, aminek ráadásul a precedenciája magasabb, mint például a == -é. Ezért ez a művelet hibára fog futni:
Ilyenkor zárójelezzük, hogy az összehasonlítást végezze el
Nyilván a 10 nem egyenlő a 8 értékével, ezért ez az állítás hamis, azaz 0 lesz az eredmény.
Logikai operátorok
Logikai értékeket kapcsolnak össze, például true / false típusokat. Nagyon fontosak lesznek majd az if feltételeknél.
| Operátor | Jelentése | Példa | Eredmény |
|---|---|---|---|
| ! | NEM (NOT) – megfordítja az igazságértéket | !(5 == 5) | false |
| && | ÉS (AND) – akkor igaz, ha mindkettő igaz | (3 > 1 && 7 < 10) | true |
| || | VAGY (OR) – csak akkor hamis, ha mindkettő hamis | (3 > 5 || 2 > 7) | false |
Pár megjegyzés hozzá: itt is fontos a zárójelezés, mert a << precedenciája magasabb, mint a logikai operátoroké
! előtag: bármi elé teheted, ami logikai értékre értékelődik, például: !(a == b)
&& – csak akkor igaz, ha mindkét oldal igaz. Ha az A hamis, akkor a B már nem számolódik ki
|| – csak akkor hamis, ha mindkét oldal hamis. Ha az A igaz, akkor a B már nem számolódik ki
| A | B | A && B |
|---|---|---|
| false | false | false |
| false | true | false |
| true | false | false |
| true | true | true |
| A | B | A || B |
|---|---|---|
| false | false | false |
| false | true | true |
| true | false | true |
| true | true | true |
| A | !A |
|---|---|
| false | true |
| true | false |
Értékadó operátorok
| Operátor | Jelentése | Példa | Magyarázat | Eredmény |
|---|---|---|---|---|
| = | egyszerű értékadás | a = b; | a értéke felveszi b aktuális értékét (a felülíródik) | ha b = 10 → a = 10 |
| += | hozzáadás és értékadás | x += 3; | rövidítés az x = x + 3 formára |
ha x 5 volt → x = 8 |
| -= | kivonás és értékadás | x -= 2; | rövidítés az x = x - 2 formára |
ha x 8 volt → x = 6 |
| *= | szorzás és értékadás | x *= 2; | rövidítés az x = x * 2 formára |
ha x 6 volt → x = 12 |
| /= | osztás és értékadás | x /= 3; | rövidítés az x = x / 3 formára |
ha x 12 volt → x = 4 (egész osztásnál) |
Néhány megjegyzés hozzá:
Az értékadás asszociativitása jobbról balra halad, azaz a = b = 10-nél először a b = 10, majd az a = 10.
A bal oldalnak írhatónak kell lennie, literálnak nem lehet értéket adni.
Típuseltérésekél konverzió történik: double d = 3.5; int x = 0; x = d -> x 3 lesz, a tört rész levágódik.
Növelő / csökkenő operátorok
| Forma | Jelentése | Példa | Egyenértékű hosszú alak | Hatás a változóra |
|---|---|---|---|---|
| ++x | növelés eggyel (prefix) | ++b; | b = b + 1; (ugyanaz, mint b += 1) | b értéke azonnal nő |
| x++ | növelés eggyel (postfix) | b++; | b = b + 1; | b nő, de a kifejezés **régi** értéket ad vissza |
| –x | csökkentés eggyel (prefix) | –b; | b = b – 1; (ugyanaz, mint b -= 1) | b értéke azonnal csökken |
| x– | csökkentés eggyel (postfix) | b–; | b = b – 1; | b csökken, de a kifejezés **régi** értéket ad vissza |
Mit jelent a prefix – postfix a gyakorlatban?
int x = 5
int y = ++x //prefix
1. lépés: ++x -> növeli x-et hatra
2. lépés: az új értéket (6) adja vissza
3. lépés: y megkapja az új értéket (6)
-> tehát x=6, y=6
Most ugyanez postfix-szel:
int x = 5;
int y = x++ //postfix
1. lépés: előbb visszaadja a régi értéket (5)
2. lépés: növeli az x-et hatra
3. lépés: y az eredeti 5-öt kapja meg
-> tehát x=6, y=5
Ha növelni akarod a változót, akkor mindegy, melyiket használod, de ha kifejezésben szerepel, akkor nem.
Ha x = 5
y = x++ + 2; -> y = 7, x = 6
y = ++x + 2 -> y = 8, x = 6
Feladatok
1. Műveletek gyakorlása: írj egy programot, ami két számot bekér, majd kiírja:
- az összegüket
- a különbségüket
- a szorzatukat
- az egész és tizedes osztás eredményét
- és a maradékot
Megoldás
2. Írj egy programot, ami két számról megmondja, hogy:
- egyenlők-e
- az első nagyobb-e
- mindkettő pozitív-e
Megoldás
3. Prefix és postfix közti különbség: magyarázd el, mit kapsz és miért?
Megoldás
4. Mennyi lesz az eredmény és miért? (műveleti sorrend)
Megoldás
Először a 2+5 számolódik ki, az 7, majd a *= értékadás. 
5. Logikai gyakorlás. Írd le, miért 1 vagy 0 az eredmény:
Megoldás
a – igaz
b – hamis – innen indul a logikai műveletünk
!a -> ha a igaz, akkor az a hamis lesz. Ekkor hamis || hamis ->az eredmény hamis. Kimenet: false
(a && !b) > mivel a b hamis, a !b igaz lesz. A igaz és B igaznál az egész kifejezés igaz.
6. Mi lesz az eredmény és miért?
int a = 5 / 2;
float b = 5 / 2;
float c = 5 / 2.0
float d = 5.0 / 2;
float e = (float)5/2;
Megoldás
1. – mindkét operandus, az 5 és a 2 egész szám (int) Egész számoknál a C++ levágja a tizedes részt.
2. float a változó, de a művelet két int között zajlik. Kiszámolja az osztást egész osztásként és csak az eredményt alakítja át float típusra
3. Az egyik operandus lebegőpontos, a másik operandust automatikusan előrelépteti lebegőpontos típusra
4. ugyanaz az eset, csak a másik oldal a lebegőpontos
5. Itt te kényszeríted az első operandust lebegőpontos típusra.
Ha szeretnéd folytatni a tanulást, itt válogathatsz a C++ anyagok között
C++ változók és adattípusok
Eddig főként szöveggel dolgoztunk - most itt az idő, hogy számokat is tároljunk, számoljunk és mérjünk! A számítógép minden adatot a memóriájában tárol. Ez a memória apró bitekből, bájtokból áll. 1 bájt = 8 bit Egy bit lehet 0 vagy 1, tehát egyetlen biten kétféle...
C++ be- és kimenet: cout, cin (iostream)
Ebben a leckében a C++ be és kimenet alapjait tanuljuk meg: hogyan írunk ki dolgokat a képernyőre std::cout-tal és hogyan olvasunk be adatokat a billentyűzetről std::cin-nel az iostream segítségével. Végigmegyünk azon, mi a különbség a '\n' és a std::endl között,...
C++ alapok: main függvény, programváz
Mielőtt belevágnánk a C++ témába, rakjunk rendet: mi az a forrásfájl, a C++ main függvény, hogyan néz ki a programváz, mik azok a headerek (#include <...>) és mit ad a C++ stardard library. Ha a környezeted még nincs kész, itt a két útmutató hozzá:– Dev-C++...