A ciklusok olyanok, mint a programozás „repeat” gombjai:

• ha valamit újra és újra kell végrehajtani,

• ha egy adatsoron végig kell menni,

• ha valamit csak addig csinálunk, amíg egy feltétel igaz,
  akkor ott biztos, hogy ciklust fogsz használni.

A C++ két klasszikus ciklusa, amit most megtanulunk:

✨ while – amíg a feltétel igaz, ismétel
✨ for – egy előre tudott, számlálós ismétlés

És hidd el, ahogy összeáll, hirtelen minden feladat egyszerűbb lesz:

• ismétlődő műveletek

• adatok összegzése

• min–max keresés

• tömbök bejárása

Most pedig lépjünk bele a ciklusok világába, kezdjük azzal, hogyan működik a while, és miért viselkedik másképp, mint a for.

A ciklusok akkor jönnek jól, amikor valamit többször egymás után szeretnénk végrehajtani. Nem akarunk százszor leírni egy utasítást, elég egyszer megadni, és a gép elismétli helyettünk.

A while kulcsszó azt jelenti:
👉 „amíg teljesül a feltétel, ismételd az utasítást.”

Ez egy úgynevezett előtesztelő ciklus, mert még belépés előtt megnézi, igaz-e a feltétel. Ha már az elején hamis, akkor egyáltalán nem fut le a ciklusmag.

Példa:

A program először megnézi, hogy i <= 10 igaz-e.
Ha igen, belép a ciklusba, kiírja a „Szia”-t, majd ++i növeli az i értékét.
Ahogy látjuk, pontosan tízszer fut le – a feltétel addig igaz, amíg az i el nem éri a 11-et.

A ciklusban található rész a ciklusmag.
A feltétel: i <= 10.
A változás: ++i, ami biztosítja, hogy a feltétel egyszer hamissá váljon, különben végtelen ciklusba futnánk.

Ha a „Szia” helyett i-t iratod ki, akkor szépen elszámol 1-től 10-ig. 

do-while – mindig lefut egyszer

A while párja a do-while, ami szintén ciklus, de egy nagyon fontos különbséggel: a do-while egyszer mindig lefut és csak utána vizsgálja a feltételt. Ezért nevezzük utótesztelő ciklusnak. 

Hiába a false feltétel, a ciklusmag egyszer biztosan lefut. Ez akkor hasznos, ha valamit mindenképp meg akarunk jeleníteni a képernyőn, pl. egy bekérést. 

A while ciklusnál megtanultuk, hogy addig ismételünk, amíg a feltétel igaz.
A for ciklusnál viszont már az elején tudjuk:

• honnan indulunk,

• meddig szeretnénk menni,

• és hogyan változik a számláló.

Ezért a for olyan, mint a „számlálós ismétlés” beépített csodafegyvere:
rövid, átlátható, és a legtöbb programozási feladatnál ez lesz a kedvenced.

A for ciklus valójában három részből áll (mind egy sorban!):
for (kezdőérték; feltétel; léptetés)

Működése

1. beállítja a kezdőértéket
2. Megvizsgálja a feltételt
3. Ha igaz, lefut a ciklusmag
4. A végén elvégzi a léptetést (pl. ++i)
5. Újra ellenőrzi a feltételt … és megy tovább.

Addig ismétel, amíg a feltétel hamis nem lesz

Ez szó szerint azt mondja: 
1. Indulj egytől
2. Menj addig, amíg i <= 10
3. Minden körben növeld eggyel

És így a program elszámol 1-től 10-ig.  

A ciklusokat nem csak külön-külön használhatjuk, hanem egymásba is ágyazhatjuk őket.
Ez azt jelenti, hogy egy cikluson belül fut egy másik ciklus.

Ennek a legegyszerűbb és leglátványosabb példája, amikor csillagokból építünk ábrát:

• a külső ciklus (i) azt mondja meg, HÁNY sor legyen,

• a belső ciklus (j) azt mondja meg, egy sorban HÁNY csillag legyen.

Ha az i értéke 1, akkor 1 csillagot írunk ki,
ha az i értéke 2, akkor 2 csillagot,
…és így tovább.

1. feladat

Kérj be a felhasználótól egy számot és írd ki az összes számot 1-től eddig az értékig

Mit csinál?

int n; -> létrehoz egy dobozt, amelyben n nevű egész szám típusú változó van
std::cin >> n; -> beteszi a dobozba azt az értéket, amit a felhasználó megadott
int i = 1 -> ezzel létrejött egy i nevű új változó, ami egy egész szám. Kapott egy kezdőértéket: 1
i <= n -> minden ciklusfuttatás előtt ezt ellenőrzi a program. Ha igaz, lefut a ciklusmag. Ha hamis, vége a ciklusnak
++i -> minden kör végén növeli az i értékét eggyel. Ez viszi előre a ciklust. 

Mi a különbség az i és az n között?
Az i csak ebben a ciklusban él, az n a cikluson kivül lett meghatározva, tehát később is vissza lehet nyúlni hozzá

2. feladat

Kérj be a felhasználótól egy egész számot (N) és számold ki, mennyi 1+2+3+ … + N összege

int N; -> bekéri az N -et
std::cin >> N; -> beteszi az N értékét egy dobozba

int osszeg = 0; -> van egy összeg változónk, ami nulláról indítja a számolást. Minden ciklusban belerakunk egy osszeg + i-t. 

for ciklusunk:
int i = 1 – ez a ciklus számlálója. Ez számolja, hányszor futott le a ciklus, illetve melyik számnál tart. A kezdeti értéke egy, célja, hogy elérje az N értéket. Tehát ez egyről indul
Feltételvizsgálat: i <= N. Ez minden kör előtt lefut. A gép megkérdezi: a jelenlegi i érték még belefér? Ha igen, lefut a ciklusmag, ha nem, kilép a ciklusból. 
N = 6, tehát belefér az 1, 2, 3, 4, 5, 6 és kilép a 7-nél. 

osszeg +=i; – ez történik minden körben: fogjuk az összeg változóban levő értékét és hozzáadjuk az aktuális i-t, majd visszarakjuk ugyanabba a dobozba. Ha i = 3, akkor osszeg = osszeg + 3. Az osszeg += i az ugyanazt jelenti, mint osszeg = osszeg + i;

3. feladat

Hány páros szám van 1 és n között?. Kérj be a felhasználótól egy n egész számot, majd vizsgáld meg 1-től n-ig az összes számot és számold meg, hány páros szám van köztük. Végül írd ki a darabszámot. 

int n; – létrehozol egy egész típusú változót, a neve: n. Ez lesz a dibiz, amibe a felhasználó által megadott szám kerül. Kiírja az üzenetet a képernyőre, a felhasználó megadja a számot. 
std::cin >> n; – beleteszi a megadott számot a dobozba. Beírtam, hogy 6, innentől az n = 6 lesz. 

int db = 0; -> egy újabb doboz, ez fogja számolni azt, hogy hány páros számot talált. Int = egész típusú változó. 0 – mert kezdetben 0 darab párosról tudunk. 

for ciklus:
int i = 1; -> létrejön egy i nevű számláló, kezdőértéke 1. Az első vizsgált szám az 1
int <= n; -> feltétel, amíg i <= n, addig fut a ciklus. Ha n = 6, akkor az i felvett értékei: 1, 2, 3, 4, 5, 6.
Amikor i = 7, a feltétel hamis, kilép
++i -> minden kör végén az i eggyel nő. 

cilusmag: {} zárójel között. if (i % 2 == 0 { db++;} Itt döntjük el, hogy az i páros-e. i % 2 == 0 (ha az i-t elosztjuk kettővel, akkor a maradék = 0). Ha ez lefut, akkor a db++ -> a db megnő eggyel. Ha az i páros, akkor a darabszám nő eggyel. 

Ha lefutott a ciklus, akkor kiírja a db számát a képernyőre.  

4. feladat

Kérj a felhasználótól egy n számot. Ezután döntsd el 1-től n-ig minden számról, hogy osztható-e hárommal. Számold meg, hány ilyen szám van és írd ki az eredményt. 

Nagyon hasonlít a megoldása az előző feladathoz, itt most csak a zárójeleket nézzük át: 
if (i % 3 == 0) -> a kerek zárójel azt jelzi, ez egy logikai feltétel, ami vagy igaz, vagy hamis. A feltételek mindig ()  – kerek zárójelben vannak. Itt azt jelenti: mit kérdezünk meg. 
{} – kapcsos zárójel, azt mutatja meg, mit csinálunk, ha a válasz igaz. 

for (int i = 1; i <= n; i++) {   // Ez a for kapcsos nyitója
if (i % 3 == 0) {                  // Ez az if kapcsos nyitója
db++;                                // if blokk belseje
}                                       // if blokk kapcsos zárója
}                                      // for kapcsos zárója

5. feladat

Kérj a felhasználótól egy n számot. Ezután vizsgáld meg 1-től n-ig minden számot, hogy 7-esre végződik-e. Számold meg, hány ilyen szám található

Ha szeretnél továbbhaladni a C++ anyagban, itt válogathatsz a leckék között:

Igen, itt kezdődik az, amikor a kód „ha ez történik → akkor azt csináld” módba kapcsol.

Képzeld el úgy, mintha a programod kapna egy saját mini döntéshozó központot:

• ha a felhasználó túl fiatal → „sorry, még nem vezethetsz”,

• ha a szám pozitív → „minden oké, gyerünk tovább”,

• ha az ugrás hosszabb, mint 8 méter → „wooow, díjazás jár!”.

A feltételek azok a kapuk, amelyek eldöntik, melyik irányba megy tovább a kódod — és hidd el, programozóként ezt az eszközt fogod a legtöbbször használni. Minden játék, minden alkalmazás, minden algoritmus tele van döntésekkel.

Ebben a leckében szépen, lépésről lépésre megnézzük:

• hogyan működnek az if elágazások,

• mikor kell else vagy else if,

• hogyan írj tökéletes logikai kifejezéseket,

• milyen tipikus hibákat érdemes elkerülni,

• és hogyan gondolkodik valójában a számítógép egy feltétel kiértékelésekor.

Lesznek könnyű és instant megérthető példák, plusz néhány olyan mini feladat is, amitől érzed majd: „Oké… most már tényleg értem.”
A végére simán megoldod majd a nagyobb projektes feladatokat is (távolugrás, síugrás, lakásfeladat), hiszen azok tele vannak feltételes szerkezetekkel.

Na, csapjunk bele, mert ez az a rész, ahol a C++ elkezd igazán élőnek tűnni!

A feltétel (condition) tulajdonképpen egy kérdés, amit a program feltesz magának:

„Igaz ez… vagy hamis?”

Nincs harmadik opció.
A C++ itt nagyon „kocka módon” gondolkodik: vagy true, vagy false.

És attól függően, melyik a válasz, a program különböző „utakon” halad tovább. Ez olyan, mintha a kód egy kereszteződéshez érne:

• Ha a feltétel igaz → akkor végrehajtja az adott utasítást.

• Ha a feltétel hamis → akkor átugorja, vagy egy másik ágba lép.

Ezért hívjuk elágazásnak is.

A feltételt a legegyszerűbben az if kulcsszóval írjuk le.
Így kommunikálsz a géppel:

if (feltétel) {
//ezt csináld, ha igaz
}

A kis zárójelen belüli rész a lényeg – itt döntöd el, hogy milyen szabály alapján lépjen tovább a program. Például: 

• a > b → nagyobb-e az egyik szám a másiknál?

• kor >= 18 → elmúlt-e a felhasználó 18 éves?

• pont >= 50 → sikerült-e a vizsga?

• ugras >= 8 → jár-e nagyobb díjazás a versenyzőnek?

Ha a feltétel igaz, a program  belép a kapun. Ha hamis, fapofával sétál tovább a következő lehetőség felé. Nézzünk rá egy példát:

Az if szuper, amikor valamit csak akkor szeretnél lefuttatni, ha egy feltétel igaz. De mi van akkor, ha azt is szeretnéd megmondani a programnak, mi történjen, ha a feltétel hamis?

Na erre van az else.

Az else az a „különben” ág:
ha az if nem teljesül → az else fut le.
Ennyi. Tiszta sor.

💡 Úgy képzeld el, mint két út közötti kapcsolót:

• if → ha páros a szám

• else → ha NEM páros, tehát páratlan

Nincs másik opció.  A szám vagy páros vagy páratlan, tehát az else mindig elkapja a fennmaradó esetet.

Nézzük egy szép, tiszta példával:

Else if

Az if és az else két helyzetet tudott megkülönböztetni: ha igaz -> ezt csináld, ha nem igaz > azt csináld. 

De a valóságban kevés dolog fekete-fehér. Többnyire nem két, hanem több lehetséges eset is van. Itt lép a képbe az else if. 
Az else if-nél a program tovább kérdez: 

➡️ „Ha az első feltétel nem igaz, akkor nézzük meg ezt a másikat!”
➡️ „Ha ez se igaz, akkor még mindig van egy következő lehetőség…”

Így szépen, sorban, logikusan vizsgálja végig a különböző feltételeket.

Miért kell a kapcsos zárójel az if után?

Ha ezt írod neki: 
if (feltétel)
       utasítás1;
       utasítás2;
akkor ő ezt így érti: 
utasítás1 -> az if-hez tartozik
utasítás2 -> nem tartozik az if-hez, mindig lefut. A {} zárójelek nélkül az if CSAK EGY UTASÍTÁST fogad be. Amit beteszem a kapcsos zárójel közé, az egy utasításnak felel meg. 
Példa:
           if (szam > 0) std::cout << „Pozitiv szam” << std::endl;
Tehát, ha a szám nagyobb mint , akor futtasd le, hogy írja ki ez egy pozitív szám
Csakhogy ha hozzáírom még ezt a sort: 
          if (szam > 0) std::cout << „Pozitiv szam” << std::endl;
           std::cout << „A szam nagyobb mint nulla” << std::endl;

Csak az első sor van hozzákötve az if-hez, a másodikat mindig lefuttatja. Így lesz helyes:
  if (szam > 0) {
                    std::cout << „Pozitiv szam” << std::endl;
                    std::cout << „A szam nagyobb mint nulla” << std::endl; }
így mind a két sor ugyanahhoz az if-hez tartozik. 

Beágyazott if-ek (nested if) – amikor egy döntésen belül újabb döntést hozunk

Előfordul, hogy egy feltétel csak akkor vizsgálható, ha egy másik már teljesült. Ilyenkor jönnek képbe a beágyazott if-ek. Ez olyan, mintha a program azt mondaná:
1. Nézzük meg az A-t
2. Ha A igaz, akkor vizsgáljuk meg a B-t is. Vagyis kétlépcsős döntést kell hozni. 

Példa: a megadott szám pozitív és páros-e?
if (szam > 0) {
if (szam % 2 == 0) {
      std::cout << „A szam pozitív és páros” << std::endl; }
else {
     std::cout << ” A szam pozitív, de páratlan” << std::endl; }
else {
     std::cout <<„A szam nem pozitív.” << std::endl;
}
Három lehetséges kimenet van:

• pozitív és páros
• pozitív és páratlan
• negatív vagy nulla

Akkor érdemes beágyazott if-et használni, ha a második feltétel csak akkor értelmezhető, ha az első igaz. Például: ha a felhasználó be van jelentkezve, akkor ellenőrizzük, hogy adminisztrátor-e.

Ha nem kell beágyazni, a két feltétel egyszerre kell, hogy igaz legyen, akkor egyszerűbb így:

if (szam >  0 && szam % 2 == 0) {
     std::cout << „A szám pozitív és páros” << std::endl; }
Csak akkor használunk beágyazott if-et, ha a vizsgálatoknak van egy sorrendje. Ha csak kombinálni akarod a feltételeket, akkor sokkal egyszerűbb a logikai operátor. 

Ha szeretnél továbbhaladni a C++ anyagban, itt válogathatsz a leckék között:

A programozásban nagyon gyakran van szükségünk egész számok tárolására – például életkorra, pontszámra, vagy éppen egy számláló értékére.
Ehhez a C++ több különböző „méretű dobozt” (típust) kínál: mindegyik egész értéket tárol, csak más tartományban.

Minél nagyobb a doboz (több bájt), annál nagyobb számokat tudsz benne elhelyezni.
Azonban a memória is értékes, ezért mindig a szükségesen legkisebb típust érdemes választani.

💡 Megjegyzés: a konkrét méretek platformfüggők. Kérdezd le: sizeof(char), sizeof(short), sizeof(int), sizeof(long), sizeof(long long).

Char – a karaktertípus C++-ban

A char szó a character rövidítése, egy 1 bájtos (8 bites) adattípus. Ez azt jelenti, hogy:

👉 256 különböző értéket tud tárolni (0–255 vagy -128–127 típustól függően).
👉 Alapvetően egy karaktert reprezentál.

De itt jön a csavar: a char valójában egy pici egész szám de a kiíratásnál betűként jelenik meg. Ez a típus a karakter ASCII-kódját tárolja. Tehát ha azt írod ki:
char c = 97;
std::cout << c; akkor az a betűként fog megjelenni, mert a 97-es az ASCII táblában az a betű. Tehát ha számot teszel a char-ba, akkor az a hozzá tartozó karakterként fog megjelenni. 

• Lehet vele egyetlen betűt is megjeleníteni, de akkor aposztróf közé kell tenni: char betu = ‘a’;
• Ki lehet vele iratni az ASCII értéket is: 
  char c = ‘A’;
  std::cout << (int)c;
• Lehet ezt is növelni eggyel:
  char x = ‘A’;
  x = x + 1;
  std::cout << x; -> ez esetben B-t kapunk, mert a B foglalja el a 66. helyet
• Túlcsordulásnál (túlléped a határt) körbefordul, tehát ha 127-hez hozzáadsz char-ban egyet, akkor -128 lesz

Tehát a char egy 1 bájtos egész típus, ami ASCII kódot tárol (0-255 vagy -128-127), kiíratva karakterként jelenik meg, de lehet számként is használni. A legtöbb fordító signed char-t használ alapból (-128-127)

Short típus

A short egy egész típus a C++-ban, ami kevesebb memóriát foglal, mint az int. Kisebb számok tárolására való – gyors, takarékos és szuper, ha nem kell óriási tartomány. 

A short legalább 2 bájt (16 bit), 16 biten pedig 2¹⁶ = 65 536 különböző érték ábrázolható.
Alapértelmezetten signed short a típusa (-32768 – + 32767 a tartománya), az unsigned short: 0 – 65535. 
Példa a használatára:

❌ Ne használd shortot, ha:

• sokat számolsz rajta (CPU-n nincs előnye)

• nagy pontosság kell

• máshonnan kapott adatot tárolsz (pl. felhasználói bevitel → inkább int)

✔ Ilyenkor jó:

• rengeteg kis számot tárolsz tömbben (memória spórolás)

• alacsony szintű, bitközeli feladatok (pl. beágyazott rendszerek)

Természetesen ez is túlcsodul, ha a határán túli értéket adsz meg: 32767 + 1 -> -32768 lesz az unsigned shortnál pedig 65535 + 1 -> 0. 

Int típus

Az int a C++ alapértelmezett egész típusa — ha valaki azt mondja, hogy “számot tárolok”, 99%, hogy intre gondol.
Nem túl kicsi, nem túl nagy — épp elég minden hétköznapi számoláshoz: életkor, összegek, pontszámok, számlálók, hőmérséklet… minden, amit egy kezdő programozó valaha tárolni fog. 😄

A legtöbb rendszerben az int 4 bájt (32 bit), tehát:

• signed int tartomány:
  −2 147 483 648 … +2 147 483 647

• unsigned int tartomány:
  0 … 4 294 967 295

Mire jó az int? 

• általános számolásokra

• ciklusszámlálókhoz

• összegek, darabszámok tárolására

• menüpontok számához

• pontszámokhoz

• gyakorlatilag mindenhez, ami egész szám

Ha nem tudod, melyik egésztípust válaszd → int.
Ez az alapértelmezett, és a CPU is erre van optimalizálva, szóval gyors.

Az int is túl tud csordulni, csak ritkábban fordul elő, mert hatalmas a tartománya. Az, hogy nálad pontosan mekkora a sizeof paranccsal tudod lekérdezni: std::cout << sizeof(int) << ” bajt\n”;
A legtöbb gépen 4 bájt. 

Long típus – amikor az int már kicsi lesz

A long egy egész számokat tároló típus C++-ban, ami legalább akkorára van méretezve, mint az int — de sok rendszeren még nagyobb tartományt enged.

⚡ Minimum mérete: 4 bájt
⚡ Tartomány: rendszerfüggő (32 vagy 64 bites architektúrától függ)

A legtöbb modern 64 bites gépen:
➡️ signed long: −9 223 372 036 854 775 808 … +9 223 372 036 854 775 807
➡️ unsigned long: 0 … 18 446 744 073 709 551 615

Mire jó a long?

Ha olyan egész számokat akarsz tárolni, amelyek:

✨ nagyobbak, mint amit az int kezel
✨ de nem akarsz egyből long long-ra ugrani
✨ vagy platformfüggetlenül akarsz írni

Tipikus példák:

• fájlméretek
• nagy ciklus számlálók,
• pénzügyi/kalkulációs adatok

Nézd meg, a te gépeden mekkora a long: 

Long long típus – ha igazán nagyon nagy szám kell

A long long a C++ egyik óriáskapacitású egész típusa. Ha az int kicsi, a long néha még pont elég…
…de amikor már brutál nagy számokkal kell számolni (banki műveletek, nagy számlálók, algoritmusok), akkor jön a megmentő: a long long

Mérete legalább 8 bájt, azaz 64 bit.  

Tartomány (signed long long)

• −9 223 372 036 854 775 808

• +9 223 372 036 854 775 807

Ez kb. 9 kvintillió — szóval simán elfér benne minden, ami a mindennapi programozásban előfordul.

Unsigned long long:

• 0 – 18 446 744 073 709 551 615

Ezt is ellenőrizd le, nálad mekkora

A lebegőpontos típusokat tört és valós számok ábrázolására használjuk. Nem egész számot akarsz? Erre van a float és a double kitalálva.

Float

Mérete 4 bájt, pontossága 6-7 számjegy. 
A tartomány nagyjából: ±10³⁸

Ez már jó arra, hogy: 

• átlagokat számolj

• százalékokat tárolj

• gyors műveleteket végezz

• kevésbé pontos számokra támaszkodj

Hátránya: veszít a pontosságából, a képen látszik, hogy a vége kicsit elcsúszik:

Mikor használjuk a float-ot?

• ha kevés memória is számít (pl. játékfejlesztésnél rengeteg koordinátát tárolsz)

• ha nem kell nagyon nagy pontosság

• ha gyors számítások kellenek

De a legtöbb hétköznapi programban inkább a double lesz a nyerő. 

Double

Mérete 8 bájt, pontossága 15-16 számjegy
A tartománya nagyjából: ±10³⁰⁸

A legtöbb C++ programban a double az alapértelmezett választás, mert pontosabb, stabilabb, komolyabb számolásokhoz ez kell 

A double is lebegőpontos, ezért néhány számot nem tud teljesen pontosan ábrázolni – de sokkal kevésbé pontatlan, mint a float. 

A bool (boolean) egy nagyon egyszerű, de mégis nagyon erős adattípus. Csak két értéke lehet: 

• true – igaz – 1
• false – hamis – 0

Ahhoz, hogy ne 1-et és 0-t írjon ki, hanem a true vagy false szavakat, használjuk a 
std::cout << std::boolalpha; kifejezést.

A bool egy bájtot foglal el, de belül egy sima szám. A használatát majd a logikai operátorok leckében bővebben megnézzük

Gratulálok! Végigmentél a C++ típusokon!

Mostanra már nem okoz gondot, hogy:

✔ tudd, mennyi memóriát foglal egy változó
✔ különbséget tegyél egész szám, lebegőpontos és logikai típus között
✔ felismerd, mikor lesz túlcsordulás
✔ használd a sizeof-ot és a formázott kiírást
✔ magabiztosan válassz megfelelő típust a feladathoz

Ez nagyon fontos alap, mert a következő leckéktől kezdve már igazi mini-programokat fogtok építeni!

Ha szeretnél továbbhaladni a C++ anyagban, itt válogathatsz a leckék között:

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

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. 

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. 

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

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

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. 

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

Értékadó operátorok

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

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

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

2. Írj egy programot, ami két számról megmondja, hogy:

• egyenlők-e
• az első nagyobb-e
• mindkettő pozitív-e

3. Prefix és postfix közti különbség: magyarázd el, mit kapsz és miért? 

4. Mennyi lesz az eredmény és miért? (műveleti sorrend) 

5. Logikai gyakorlás. Írd le, miért 1 vagy 0 az eredmény:  

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;

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, mikor miért jobb az egyik, miért harapja le a szóköz utáni részt a >> és hogyan oldja meg ezt az std::getline + std::ws / cin.ignore. 

A lecke célja, hogy a C++ be- és kimenet rutinszerű legyen: tudj számot és teljes nevet beolvasni, szépen formázva kiírni (pl. két tizedessel), és alap validitást csinálni (hibás input esetén törölni a hibajelzőt és kiüríteni a sort). A végén rövid, gyakorlati mini feladatokkal zárunk, hogy azonnal be is gyakorold. 

Mi az az std?

A standard library (szabványkönyvtár) dobozcímkéje, hivatalosan névtér (namespace). A könyvtárban rengeteg név van (cout, cin, string, vector …), és hogy ne ütközzenek a te saját neveiddel, előtte kiírjuk, hogy std:: – így jelezzük a fordítónak, hogy ezt a nevet a standard könyvtárból szeretném. 

Mi az a cout

A cout egy előre elkészített objektum a szabványkönyvtárban, amely a szabványos kimenetre (konzol/ablak) ír. Console output. Nekünk most elég annyi, hogy ez az a dolog, amivel kiírunk valamit a képernyőre. 

Mi a <<?

A << „folyamba helyezés” operátora. Jelentése: tedd be ezt az adatot a kimeneti folyamba, balról jobbra dolgozik és láncolható: 

Mind a két esetben ugyanaz lesz a kiírás – nem kell külön sorba újra kiíri az std::cout sort, elég csak ezzel << az operátorral felsorolni és a legvégét lezárni egy pontosvesszővel. 

Mit csinálnak?

• ‘\n’ – egy új sor karakter. Simán sortörést jelent
• std::endl sort tör és mellette kiüríti a kimeneti puffert is. Ez akkor fontos, ha azonnal látni akarod a kiírást. 

Mikor melyiket érdemes használni?
Alapból használd az ‘\n’ -t, mert gyorsabb, de ha biztosra akarsz menni, hogy a szöveg rögtön megjelenjen, akkor std::endl

Gondolj az std::cin-re úgy, mint egy futószalagra (pufferre), amin karakterek érkeznek. 

• A >> operátor a whitespace-ig (szóköz/Enter/Tab) olvas egy darabot.
• A getline Enterig olvas teljes sort (szóközökkel együtt)
• A get egy darab karaktert vesz le – akár szóközt vagy Entert is

Hova tegyük az adatot? 

Szöveget std::string-be, számot int/double-ba teszünk. A változónév lehet betű, szám, alsóvonás, de nem kezdődhet számmal és nem lehet kulcsszó (pl. int, double, return stb.)

Mi történt itt? Csak a vezetéknevet vette be, mert a >> az első szóközig olvasott csak. Ha szeretnénk mind az egész sort megjeleníteni, akkor a megoldás az std::getline lesz

Számok beolvasása (int, double)

Az >> operátor szóközig olvas és rögtön megpróbálja átalakítani az értéket a cél típusára

Több adatot egymás után is bekérhetsz egy sorban – a >>-t mindegy, hogy szóköz, tab, vagy Enter választja el 

Szóköz és Enter csapdák: std::ws és std::cin.ignore

Képzeld el a bemenetet (stdin) egy futószalagnak. Az >> operátor szóközig olvas (szóköz, Enter, Tab = whitespace), a soron következő whitespace-t pedig rajtahagyja a szalagon. Ezért van az, hogy szám beolvasása után egy std::getline néha üres sort kap: az előző Enter még ott csücsül elől. 

Két egyszerű eszközünk van erre: 

1.) std::ws – „whitespace-porszívó”

Az std::ws felfalja az elején álló whitespace-eket (Entert is)

Mikor jó? 
Ha >> után egyból sorbeolvasás (getline) jön vagy ha nem baj, hogy minden kezdő szóközt is elnyel (pl. a felhasználó véletlenül beütött pár space-t)

2. std::cin.ignore

Az ignore kifejezetten arra való, hogy eldobjunk karaktereket a puffer elejéről. Klasszikus minta: dobt el a teljes sor maradékát (az Enterig), aztán olass getline-nel

Mikor jó? 

Ha biztosan a sor végét szeretnéd kidobni (pl. >> után jön még egy getline, vagy ha a menüben/űrlapon szeretnéd letisztítani a sort egy rövid karakteres input után.  

Mi történik? 

Nem a számot dobjuk el, hanem azt, ami utána marad a pufferben – tipikusan az Entert, esetleges szóközöket, maradék karaktereket. Mindig van eldobnivaló amikor >>-val olvasol, mert a >> csak a tokenig eszik, a leválasztó (whitespace, ‘\n’) bent marad. 
Tehát: írsz valamit, Entert nyomsz: akkor beírod: 5 + Enter
A pufferbe kerül [‘5’] [‘\n’]
beírod: int darab;
std::cin >> darab //megeszi az ‘5’-öt, a pufferben marad: [‘\n’] 
Ha most rögtön jönne a std::getline(…), az az első karakterig a sor végéig olvas. De az első karakter már a ‘\n’, ezért üres sort kapsz. Ezeket ignoráljuk. Eldob mindent a sor végéig, beleértve az ‘\n’-t is, így az std::getline a következő sort kapja meg, nem az üreset. 

Ha nagyon röviden kéne megfogalmazni: >> meghagyja a leválasztót, a maradékot el kell dobni. std::getline sorig olvas, ha elsőnek ‘\n’ van, üres lesz

Mikor használj std::ws-t és mikor std::cin.ignore-t?

Ha csak Enter maradt elől -> std::ws. Elég csak egy whitespace kiszippantása.
Ha a sorban maradék szöveg is lehet, akkor használd az ignore(…, ‘\n’) -t

Puskasor – C++ be és kimenet

• std::cout << ... → kiírás. Láncolható. '\n' gyors newline, std::endl newline + puffer ürítés.

• std::cin >> x → whitespace-ig olvas és konvertál 

• std::getline(std::cin, s) → teljes sor az Enterig (szóközökkel együtt).

• >> után getline előtt: ignore(..., '\n') vagy getline(std::cin >> std::ws, s).

Mi jön ezután?

A következő fejezetben a változókról és típusokról beszélünk (egész, valós, karakter, szöveg; névadás, alapértelmezett értékek, típuskonverziók, const), hogy a most beolvasott értékeket jól tudjuk tárolni és számolni velük.

• ⬅️ Előző lecke: C++ main függvény – programváz, headerek

• ➡️ Következő lecke: C++ változók és típusok – int, double, char, std::string

• 🏠 Vissza az áttekintőhöz: C++ alapok – összes lecke