# Informatika leckék 9-12 osztályosoknak Matematika-Informatika Light szakon tanultak összesítése első évtől a negyedikig. Teszt alatti csalás / puskázás következményei fölött felelősséget a szerző nem vállal! # Bevezetés ## Programozási alapfogalmak Gépi kód: az adott gép processzorának a "nyelve" Assembly nyelv: a gépi kód emberibb változata, ahol minden gépi kódú utasításnak egy kis angol neve van. Magas szintű programozási nyelvek: könnyű bennük ismétlési és döntési szerkezeteket, valamit algoritmusokat készíteni. ## Programkészítés lépései 1. A feladat megfogalmazása 2. Tervezés (algoritmusok) 3. Kódolás (programírás) 4. Tesztelés, ellenőrzés + kijavítás 5. Dokumentálás 1. Felhasználói dokumentálás 2. Fejlesztői dokumentálás ## Értelmezések Algoritmus: Azon lépések sorozata amely feladat megoldásához vezet. Program: a számítógépen megírt algoritmus # Az algoritmusok leírásának módszerei 1. Folyamatábra 2. Mondatszerű leírás (pszeudokód) 3. Struktogramm ## A folyamatábra A műveleteket blokkok segítségével írjuk le. A fontosabb blokkok: ![1](https://2370504955-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-LNeGjFVCqq0MtkPhjib%2F-LNeOgI_MqcYlN16CvMx%2F-LNePQCmKQZp-84PAKVl%2Finditoblokk.png?alt=media\&token=45406792-9cad-4db8-8b55-d3e9c1a0dab7) ![Záró blokk](https://2370504955-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-LNeGjFVCqq0MtkPhjib%2F-LNeOgI_MqcYlN16CvMx%2F-LNePifohO8clad63fT9%2Fzaroblokk.png?alt=media\&token=65f8cb71-e0dd-4b78-907c-9e142bf99291) ![Ki- és bemeneti blokk](https://2370504955-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-LNeGjFVCqq0MtkPhjib%2F-LNeOgI_MqcYlN16CvMx%2F-LNeQ213Ub5Q1saaIeEa%2Fkibemenetiblokk.png?alt=media\&token=e5c78b8e-9ef4-4fd3-afd8-532071dbbc3c) ![Műveletek blokkja](https://2370504955-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-LNeGjFVCqq0MtkPhjib%2F-LNeOgI_MqcYlN16CvMx%2F-LNeQAgw1yplihmEnhkS%2Fmuveletblokk.png?alt=media\&token=4a957932-d080-4dc4-9a15-5370c0054bb7) ![](https://2370504955-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-LNeGjFVCqq0MtkPhjib%2F-LNeQGfCVeZLFeLK2C0z%2F-LNeQaR6bnOENefldpyk%2Fdontesblokk.png?alt=media\&token=8799f06b-4fed-409a-add4-bc4b47bbe008) ## A folyamatábra előnye: Áttekinthető ## A folyamatábra hátránya: 1. Nagyobb algoritmusok írására nem alkalmas 2. Nehéz kijavítani ## Mondatszerű leírás (pszeudokód) Algoritmusok leírása utasítások segítéségével történik ``` Be: a,b c = (a + b) / 2 Ha c >= 4.5 akkor Ki: "Átment" külömben Ki: "Megbukott" ``` ### A pszeudokód előnye Nehezebb algoritmusok írására is alkalmas Nagyon hasonlít a programozási nyelvekhez, ezért könnyen átalakítható programmá. ### A pszeudokód hátránya Nem annyira áttekinthető ## A struktogram Próbálták mindkét módszer előnyeit ötvözni, de jelenleg kevés helyen használják. # Az algoritmusok leírásának elvei ## Az adatok Az adatok jellegüknél fogva sokfélék lehetnek. Vannak olyanok, amelyek a feldolgozás során változtatják az értéküket, ezeket "változóknak" nevezzük, viszont vannak olyan adatok amelyek változatlanul maradnak, ezeket "állandóknak" vagy "konstansoknak" nevezzük. Annak tekintetében, hogy az adatok milyen jellegű információkat tudnak tárolni, a következő típusokat különböztethetjük meg: 1. Numerikus 1. Egész 2. Valós 2. Karakterlánc 3. Logikai #### Megjegyzések * Valós típusú adatok esetén, a tizedesvessző helyett "tizedespontot" használunk. * Például: 3.25 és 6.69 * A karakterláncokat aposztrófok közé írjuk. * Például: "alma" vagy "Körte" * A logikai adatok kétfélék lehetnek: igaz és hamis. # Műveletek egész típusú adatokkal A következőkben azok a műveletek kerülnek felsorolásra, amelyeket ha elvégzünk 2 egész típusú számra, az eredmény szintén egész lesz. ``` Összeadás (+) Kivonás (-) Szorzás (*) Egész osztás, "div" [] Maradékképzés, "mod" % ``` #### Megjegyzések Ha a mod műveletet használjuk 2 egész szám oszthatóságának vizsgálatára. $$ a mod b <=> b|a $$ # Műveletek egész típusú számokkal ``` Összeadás (+) Kivonás (-) Szorzás (*) Osztás (/) Hatványozás (ismételt szorzás) Gyökvonás (sqrt) ``` #### Megjegyzések Az informatikában a műveletek sorrendje ugyan az mint matematikában. Ha a sorrendet megszeretnénk változtatni, akkor ezt megtehetjük zárójelek segítségével. Informatikában csak kerek zárójeleket használjuk. # Műveletek karakterlánc típusú adatokkal ``` Konkatenáció (+), vagy összefüggés Pl: "csoki" + "fagyi" = "csokifagyi" ``` # Műveletek logikai típusú adatokkal A logikai típusú adatok összehasonlító (relációs) operátorok segítségével írjuk le. ``` == egyenlő !=, <> nem egyenlő <= kissebb vagy egyenlő >= nagyobb vagy egyenlő ``` ## Logikai kifejezések összekapcsolása Több logikai kifejezés segítségével összetett logikai kifejezést is alkothatunk, ha ezeket a következő operátorok valamelyikével összekapcsoljuk: ``` && (és) || (vagy) ! (tagadás) ``` | a | b | a &\&b | a \|\| b | !a | !b | | - | - | ------ | -------- | -- | -- | | 1 | 1 | 1 | 1 | 0 | 0 | | 1 | 0 | 0 | 1 | 0 | 1 | | 0 | 1 | 0 | 1 | 1 | 0 | | 0 | 0 | 0 | 0 | 1 | 1 | # Értékadó műveletek Az algoritmust nem konkrét értékekkel írjuk le, hanem általánosított értékekkel (változók, állandók / konstansok), Minden változónak van egy neve (azonosítója), egy típusa és egy értéke. A változóknak a program során értéket kell adni a következő módon: ``` VÁLTOZÓNÉV <-- ÉRTÉK / KIFEJEZÉS vagy VÁLTOZÓNÉV = ÉRTÉK / KIFEJEZÉS ``` A változónevekre a következő szabályok vonatkoznak: * Lehet az angol ABC kis- és nagybetűiből álló rövidítés is * Tartalmazhat számokat, de nem kezdődhet számmal * A különleges karakterek közül csakis az "alul vonás" (\_) karaktert tartalmazhatja. # A strukturált programozás alapjai A programozás elméletében szereplő alapelv szerint bármilyen algoritmus felépíthető a következő struktúrák segítségével * Lineáris struktúra * Elágazási struktúra * Ismétlő struktúra ## Lineáris struktúra Akkor beszélünk lineáris struktúráról amikor az algoritmus lépései egymás után következnek és az algoritmus nem tartalmaz elágazásokat, feltételeket vagy ismétlődéseket. ## Elágazási struktúra Az algoritmus készítése során találkozhatunk olyan helyzetekkel, amikor egy feltétel teljesülésekor egy bizonyos műveletet kell végeznünk, ellenkező esetben, pedig egy másikat. Ezeket az elágazásokat "döntéseknek" is nevezzük. Kétféle döntés létezik: * Egyágú döntés * Kétágú döntés #### Egyágú döntés általános alakja pszeudokódban ``` Ha FELTÉTEL, akkor: művelet_1 ``` #### Megjegyzés Először kiértékelődik a feltétel, ha a feltétel igaz akkor az igaz ágon hajtódnak végre a műveletek, különben nem történik semmi. #### Kétágú döntés általános alakja pszeudokódban ``` Ha FELTÉTEL, akkor: művelet_1 különben: művelet_2 ``` #### Megjegyzés Kiértékelődik a feltétel, ha a feltétel igaz, akkor az igaz ágon hajtódnak végre a műveletek, különben a hamis ágon. ## Ismétlőstruktúra (ciklusok) Egy feladat megoldása során előfordulhat, hogy egy bizonyos műveletsort többször kell elvégezni. Ezeket ismétlődésnek vagy ciklusoknak nevezzük. Kétféle ciklus létezik: * Ahol ismerjük az ismétlődések (iterációk) számát: számlálós ciklus * Ahol nem ismerjük az ismétlődések (iterációk) számát: feltételes ciklus ### Számlálós ciklus Alakja pszeudokódban: ``` Minden CIKLUSVÁLTOZÓ <-- KEZDŐÉRTÉK, VÉGÉRTÉK, végezd el: műveletek / ciklus utasításai ``` #### Megjegyzés A számlálós ciklus úgy működik, hogy a ciklusváltozó felveszi a kezdőértéket, végrehajtja a ciklus utasításait, automatikusan 1-el nő / csökken az értéke, majd visszatér a ciklus elejére, majd újra elvégzi az utasításokat. Ezt mindaddig végzi amíg a ciklusváltozó el nem éri a végértéket. Ha a ciklus kezdő- és végértéke megegyezik akkor a ciklus egyszer erre az értékre végrehajtja a műveleteket. Ha a kezdőérték szigorúan nagyobb a végértéknél a ciklus egyszer sem hajtja végig a műveleteket. Alapértelmezésben a számlálós ciklus mindig növekvő, de létezik csökkenő számláló ciklus is, melynek pszeudokódban az alakja a következő: ``` Minden CIKLUSVÁLTOZÓ <-- KEZDŐÉRTÉK, VÉGÉRTÉK, -1, végezd el: utasítások ``` A csökkenő számlálós ciklus csak akkor tudja végrehajtani az utasításokat ha a kezdőérték nagyobb vagy egyenlő a végértéknél. Vannak olyan algoritmusok, amelyekben a ciklusváltozó értékét nem használjuk fel a ciklus utasításai között. Csak azért használjuk a ciklust, hogy az ismétlődések megtörténjenek. ### Feltételes ciklus Létezik: * Elültesztelő feltételes ciklus * Hátultesztelő feltételes ciklus #### Az elültesztelő ciklus Alakja pszeudokódban ``` Amíg FELTÉTEL, végezd el: utasítások / ciklus műveletei ``` #### Megjegyzések Az elültesztelő ciklus úgy működik, hogy először kiértékelődik a feltétel, ha a feltétel igaz akkor az igaz ágon végrehajtódnak a műveletek, majd újra kiértékelődik a feltétel (tehát megtörtént az ismétlődés / iteráció). Ha a feltétel hamissá válik, akkor az algoritmus kilép a ciklusból. Vigyáznunk kell arra, hogy bizonyos számú ismétlődés után a feltétel hamissá váljon, mert különben végtelen ciklushoz jutunk. Ehhez egy olyan műveletre van szükség a cikluson belül, amely változtatja a feltételben megjelenő változó(k) értékét. #### A hátultesztelő ciklus Alakja pszeudokódban ``` Ismételd: utasítások Ameddig FELTÉTEL ``` #### Megjegyzések A hátultesztelős ciklus úgy működik, hogy egyszer végrehajtódnak a műveletek, majd kiértékelődik a feltétel. Ha a feltétel hamis akkor újból végrehajtódnak a műveletek és ismét kiértékelődik a feltétel, tehát megtörténik az ismétlődés (iteráció). Ha a feltétel igazzá válik akkor az algoritmus kilép a ciklusból. Vigyáznunk kell arra, hogy a műveletek között legyen olyan művelet amely változtatja a feltételben szereplő változó(k) értékét. Előfordulhat, hogy egy programban szereplő változókra valamilyen feltétel van kiszabva és ha beolvasáskor a beolvasott érték nem felel meg ennek a feltételnek akkor újból bekérjük mindaddig amíg a beolvasott érték megfelel a feltételnek. ``` Ismételd: Be: szam Ameddig szam > 0 ``` #### Elöltesztelő és hátultesztelő ciklusok összehasonlítása Hasonlóságok * Mindkettő feltételes ciklus * Mindkettőnél szükség van egy módosító kifejezésre, hogy ne kapjunk végtelen ciklust. Különbségek * Míg az elültesztelő ciklus az igaz ágon halad tovább, addig a hátultesztelő ciklus a hamis ágon. * A hátultesztelő ciklusban egyszer biztos, hogy lefutnak az utasítások, míg az elültesztelő ciklusban olyan is lehet, hogy egyszer sem. # Elemi algoritmusok (pszeudokód) ## Egy szám valódi osztóinak kiírása ``` Például: 12 osztói: 1, 2, 3, 4, 6, 12 12 valódi osztói: 2, 3, 4, 6 12 nem valódi osztói: 1, 12 ``` Alakja pszeudokódban ``` Be: szam Minden oszto <-- 2, szam-1 végezd el: Ha szam % oszto == 0, akkor: Ki: oszto + " " ``` ## Prímszámvizsgáló Prímszám - egy olyan természetes szám, amely csak 1-el és önmagával osztható. Alakja pszeudokódban ``` Be: szam prim_e = igaz Minden oszto <-- 2, [sqrt(szam)] végezd el: Ha szam % oszto == 0, akkor: prim_e = hamis Ha prim_e == igaz, akkor: Ki: "Prímszám" különben: Ki: "Nem prímszám" ``` ## Elsőfokú egyenlet Alakja pszeudokódban ``` Be: a, b Ha a == 0 && b == 0, akkor: Ki: "Végtelen sok megoldás" Ha a != 0 && b == 0, akkor: Ki: "Nincs megoldás!" Ha a != 0 && b == 0, akkor: Ki: "x = 0" Ha a != 0 && b != 0, akkor: x = (-1) * b / a Ki: "Megoldás: " + x ``` ## Tökéletes szám Tökéletes szám: Ha a szám egyenlő a nála kisebb osztóinak összegével Alakja pszeudokódban: ``` Be: szam osszeg = 0 Minden oszto <-- 1, [szam / 2], végezd el: Ha szam % oszto == 0, akkor: osszeg = osszeg + oszto Ha szam == osszeg, akkor: Ki: "A megadott szám tökéletes!" különben: Ki: "A megadott szám tökéletlen!" ``` ## Barátságos számok Barátságos számok: Ha az egyik szám nála kisebb osztóinak összege egyenlő a másik számmal és fordítva. ``` Például: 220 és 286, mert 220 osztóinak összege egyenlő 286-al, és 286 osztóinak összege egyenlő 220-al. ``` Alakja pszeudokódban: ``` Be: a, b osszeg_a = 0 osszeg_b = 0 Minden oszto_a <-- 1, [a / 2], végezd el: Ha a % oszto_a == 0, akkor: osszeg_a = osszeg_a + oszto_a Minden oszto_b <-- 1, [b / 2], végezd el: Ha b % oszto_b == 0, akkor: osszeg_b = osszeg_b + oszto_b Ha osszeg_a == b && osszeg_b == a, akkor: Ki: "A megadott számok barátságos számpárok!" különben: Ki: "A megadott számok nem barátságos számpárok!" ``` ## Armstrong-féle szám Armstrong-féle szám: Egy 3 jegyű természetes szám amelynek számjegyeinek köbének összege egyenlő a számmal. ``` Például: 153 Armstrong-féle, mert 1^3 + 5^3 + 3^3 = 153 ``` Alakja pszeudokódban: ``` Be: szam seged = szam osszeg = 0 Amíg szam > 0, végezd el: osszeg = osszeg + ((a % 10) + (a % 10) + (a % 10)) a = [a / 10] Ha seged == osszeg, akkor: Ki: "A megadott szám Armstrong-féle szám!" különben: Ki: "A megadott szám nem Armstrong-féle szám!" ``` ## Legnagyobb közös osztó és legkisebb közös többszörös Alakja pszeudokódban ``` (Legkisebb közös többszörös nélkül!) Be: a, b Ha a == 0 && b == 0, akkor: Ki: "Nincs" Ha a == 0 && b != 0, akkor: Ki: b Ha a != 0 && b == 0, akkor: Ki: a Ha a != 0 && b != 0, akkor: Amíg a != b, végezd el: Ha a > b, akkor: a = a - b különben b = b - a Ki: a ``` #### Megjegyzések A fenti algoritmus két szám legnagyobb közös osztóját határozza meg. A módszer a következő: amíg a két szám nem egyenlő, megvizsgáljuk melyik szám a nagyobb és a nagyobb szám értékét megváltoztatjuk a nagyobb szám minusz a kisebb számra. Amikor a két szám egyenlővé válik, akkor a két szám valamelyike lesz a legnagyobb közös osztó. Ha a legkisebb közös többszöröst is szeretnénk kiszámítani, akkor azt megtehetjük egy sima kiírás blokkal, ami a következő képen néz ki: ``` seged_a = a seged_b = b .... Ki: "Legkisebb közös többszörös: " + seged_a * seged_b / a // Az itt megjelenő 'a' a számítás után va, míg a seged_a-ba tárolt // az az 'a' értéke számítás előtt. ``` ### Eukleidész algoritmusa (L.N.K.O kiszámítására) Alakja pszeudokódban ``` Be: a, b seged_a = a seged_b = b lnko = 0 lkkt = 0 Ha a < b, akkor: p = a a = b b = p Amíg b != 0, végezd el: m = a % b a = b b = m lnko = a lkkt = seged_a * seged_b / lnko Ki: "L.N.K.O: " + lnko Ki: "L.K.K.T: " + lkkt ``` ## Palindrom Palindrom: Ha egy szám egyenlő a fordítottjával (tükörképével -> tükörszám) ``` Például: 101, 11011, 110011, 1110111, 94649, 946649, ... ``` Alakja pszeudokódban ``` Be: szam seged_szam = szam palindrom = 0 Amíg szam > 0, végezd el: palindrom = palindrom * 10 + szam % 10 szam = [szam / 10] Ha seged_szam == palindrom, akkor: Ki: "A megadott szám palindrom!" különben: Ki: "A megadott szám nem palindrom!" ``` ## Tízes számrendszerből kettesbe való alakítás Alakja pszeudokódban ``` Be: szam10 hatv = 1 szam2 = 0 Amíg szam10 > 0, végezd el: szam2 = szam2 + (szam10 % 2) * hatv hatv = hatv * 10 szam10 = [szam10 / 2] Ki: "A megadott szám kettes számrendszerben: " + szam2 ``` ## Kettes számrendszerből tízesbe alakítás Alakja pszeudokódban ``` Be: szam2 szam10 = 0 hatv = 1 Amíg szam2 > 0, végezd el: szam10 = szam10 + (szam2 % 10) * hatv hatv = hatv * 2 szam2 = [szam2 / 10] Ki: "A megadott szám tízes számrendszerben: " + szam10 ``` ## Egy szám számjegyeinek összege Alakja pszeudokódban ``` Be: szam osszeg = 0 Amíg szam > 0: osszeg += szam % 10 szam /= 10 Ki: "A megadott szám számjegyeinek összege: " + osszeg ``` # Elemi algoritmusok (C++-ban megírva) ## Egy szám valódi osztoinak kiírása ```cpp int szam; cout << "Add meg a szamot: "; cin >> szam; for( int oszto = 2; oszto < szam / 2; oszto ++ ) { if( szam % oszto == 0) { cout << oszto << " "; } } ``` ## Prímszámvizsgáló ```cpp int szam; bool prim_e = true; for( int oszto = 2; oszto < sqrt(szam); oszto++ ) { if( szam % oszto == 0) prim_e = false; } if( prim_e ) { cout << "Prímszám!"; } else { cout << "Nem prímszám!"; } ``` ## Elsőfokú egyenlet ```cpp int a, b; cout << "a: "; cin >> a; cout << "b: "; cin >> b; if( a == 0 && b == 0 ) { cout << "Végtelen sok megoldás!"; } if( a != 0 && b == 0 ) { cout << "x = 0" ; } if( a != 0 && b != 0 ) { x = (-1) * (b / a); cout << "Megoldás: x = " << x; } ``` ## Tökéletes szám ```cpp int szam; int osszeg = 0; cout << "Add meg a szamot: "; cin >> szam; for(int oszto = 1; oszto < szam / 2; oszto ++ ) { if( szam % oszto == 0 ) { osszeg += oszto; } } if( szam == osszeg ) { cout << "A megadott szám tökéletes!"; } else { cout << "A megadott szám tökéletlen!"; } ``` ## Barátságos számok ```cpp int a, b; int osszeg_a = 0; int osszeg_b = 0; cout << "a: "; cin >> a; cout << "b: "; cin >> b; for( int oszto_a = 1; oszto_a < a / 2; oszto_a++ ) { if( a % oszto_a == 0 ) { osszeg_a += oszto_a; } } for( int oszto_b = 1; oszto_b < a / 2; oszto_b++ ) { if( b % oszto_b == 0 ) { osszeg_b += oszto_b; } } if( osszeg_a == b && osszeg_b == a ) { cout << "A megadott számok barátságos számopárok!"; } else { cout << "A megadott számok nem barátságos számpárok!"; } ``` ## Armstrong-féle szám ```cpp int szam; int seged; int osszeg = 0; cout << "Add meg a számot: "; cin >> szam; seged = szam; while( szam > 0 ) { int ut_szamjegy = szam % 10; osszeg += ut_szamjegy * ut_szamjegy * ut_szamjegy; szam /= 10; } if( seged == osszeg ) { cout << "A megadott szám Armstrong-féle szám!"; } else { cout << "A megadott szám nem Armstrong-féle szám!"; } ``` ## Legnagyobb közös osztó és legkisebb közös többszörös ```cpp int a, b; cout << "a: "; cin >> a; cout << "b: "; cin >> b; if( a == 0 && b == 0 ) { cout << "Nincs LNKO!"; } if( a == 0 && b != 0 ) { cout << "LNKO = " << b; } if( a != 0 && b == 0 ) { cout << "LNKO = " << a; } if( a != 0 && b != 0 ) { while( a != b) { if( a > b) { a = a - b; } else { b = b - a; } } cout << "LNKO = " << a; } /** Ha LKKT-t is akarunk számolni akkor a megjegyzésben leírt eljárást kell alkalmazni! **/ ``` ## Eukleidész algoritmusa (L.N.K.O kiszámítására) ```cpp int a, b; int seged_a, seged_b; int lnko = 0, lkkt = 0; cout << "a: "; cin >> a; cout << "b: "; cin >> b; seged_a = a; seged_b = b; if( a < b ) { int p = a; a = b; b = p; } while( b != 0 ) { int m = a % b; a = b; b = m; } lnko = a; lkkt = seged_a * seged_b / lnko; cout << "LNKO = " << lnko << endl; cout << "LKKT = " << lkkt; ``` ## Palindrom ```cpp int szam; int palindrom = 0; int seged_szam = a; cout << "Add meg a számot: "; cin >> szam; seged_szam = a; while( szam > 0 ) { palindrom = palindrom * 10 + szam % 10; szam /= 10; } if( seged_szam == palindrom ) { cout << "A megadott szám palindrom!"; } else { cout << "A megadott szám nem palindrom!"; } ``` ## Tízes számrendszerből kettesbe való alakíás ```cpp int szam10; int hatv = 1; int szam2 = 0; cout << "Add meg a számot: "; cin >> szam10; while( szam10 > 0 ) { szam2 += (szam % 2) * hatv; hatv *= 10; szam10 /= 2; } cout << "A megadott szám kettes számrendszerben: " << szam2; ``` ## Kettes számrendszerből tízesbe való alakítás ```cpp int szam2; int szam10 = 0; int hatv = 1; cout << "Add meg a számot: "; cin >> szam2; while( szam2 > 0) { szam10 += (szam2 % 10) * hatv; hatv *= 2; szam2 /= 10; } cout << "A megadott szám tízes számrendszerben: " << szam10; ``` # C++ programozás a Code::Blocks IDE-ben! ## Kód indentálása Programozás során arra is figyelnünk kell, hogy a kód, vagyis a program sorai, szépen legyenek rendezve. Ezt úgy érhetjük el, hogy struktúrán belül a sorokat egy TABbal bennebb írjuk. Például: ```cpp while(a > 0){ if(a == b && a > 0){ a = a + b; b = b + 2; } a = 3 - b; } ``` # A C++ program felépítése, adatok leírása és feldolgozása Minden C++ program tartalmaz egy főfüggvényt, amely a program futásakor végrehajtásra kerül, és ez a következő: ```cpp int main() { ... return 0; } ``` A főfüggvény tartalmazza a változók deklarálását (itt határozzuk meg, hogy milyen változókat használunk és ezek milyen adattípusúak). Ez után következnek a főfüggvény utasításai. A főfüggvény előtti részen a függvény prototípusokat kell beépíteni (fejállományok, vagy header), ezek tartalmazzák azoknak a függvényeknek a leírását, amelyeket a program során használunk. Ezeket a beépítéseket a "#include" után adjuk meg. Például ```cpp #include #include #include #include #include ... #include <- preprocesszor <...> <- fejlécállomány elnevezése ``` #### Egy példa program ```cpp #include // Fejállomány, tartalmazza a cin-t és a cout-ot using namespace std; int main() { int a; // deklarálás cout << "Adj meg egy számot: "; // Kiírás cin >> a; // Beolvasás cout << "A beolvasott szám: " << a << endl; // Kiíratás return 0; } ``` #### Megjegyzések C++-ban MINDEN sor végére pontosvesszőt (;) kell írni, kivéve: * a fejállomány beépítése után * a kapcsos {} zárójelek után * a struktúrák után. # A C++ nyelv karakterkészlete Minden programot a következő karakterekkel írunk le: * Az angol ábécé kis- és nagybetűi * Numerikus karakterek (számok) * Különleges karakterek (Például: (, ), \*, \_, >>, <<, ...) A változóknak és függvényeknek / programoknak ha nevet (azonosítót) szeretnénk adni, akkor az angol ábécé kis- és nagybetűit használhatjuk. Szerepelhetnek benne számjegyek, de nem kezdődhet a név számjeggyel és tilos a speciális karakterek használata, kivételt képez az alul vonás (\_). A C++ nyelvben vannak fenntartott kulcsszavak, ezeket célirányosan szabad csak használni. Például: int, for, if, while, bool, ... A program utasításain kívül készíthetünk megjegyzéseket is, ezeket a program a végrehajtás során nem veszi figyelembe. ``` Megjegyzés több sorban: /* MEGJEGYZÉS_1 MEGJEGYZÉS_2 ... */ Megjegyzés egy sorban: /// MEGJEGYZÉS ``` # Adattípusok C++-ban A program futása során az adatokat állandók (konstansok) vagy változók segítségével tároljuk. A használatuk előtt kötelező meghatározni ezek típusát. A C++-ban a következő adattípusok léteznek: | Adattípus | Értékkészlet | Méret (bájt) | | ------------------ | ------------------------- | ------------ | | char | -128 -> 127 | 1 | | unsigned char | 0 -> 255 | 1 | | short | -32768 -> 32767 | 2 | | unsigned short | 0 -> 65535 | 2 | | int | -2147483648 -> 2147483647 | 4 | | unsigned int | 0 -> 42494967295 | 4 | | long | -2147483648 -> 2147483647 | 4 | | unsigned long | 0 -> 4294967295 | 4 | | long long | -9 \* 10^18 -> 9 \* 10^18 | 8 | | unsigned long long | 0 -> 10^19 | 8 | | float | 3.4E-38 -> 3.44E+38 | 4 | | double | 1.7E-308 -> 1.7E+308 | 8 | | long double | 3.4E-4932 -> 3.4E+4932 | 10 | | bool | true / false | 1 | #### A fenti táblázatból * Egész típusúak: char, unsigned char, short, unsigned short, int, unsigned int, long, unsigned long, long long, unsigned long long * Valós típusúak: float, double, long double * Logikai: bool * Karakter: char, unsigned char #### Megjegyzések A sizeof() függvény visszatéríti, hogy az adott változótípus hány byte-on van tárolva. Például: ```cpp sizeof(int) -> 4 byte sizeof(char) -> 1 byte sizeof(long) -> 4 byte sizeof(long long) -> 8 byte sizeof(float) -> 4 byte sizeof(double) -> 8 byte sizeof(long double) -> 12 byte sizeof(bool) -> 1 byte (8 bit = 1 byte) ``` # Műveletek C++-ban ``` Összeadás (+) Kivonás (-) Osztás (/) Maradékképzés (% vagy mod) ``` Az oszás művelet úgy működik, hogy ha egész típusú adatot egész típusú adattal osztunk, akkor az eredmény is egész lesz (egész osztás, vagy "dice"), ha valós adatot valóssal osztunk, akkor az eredmény is valós. #### Megjegyzések Ha azt szeretnénk, hogy a kiírt eredmény az általunk választott adattípusban jelenjen meg, akkor azt úgy tehetjük meg, hogy a kifejezés elé zárójelben odaírjuk az adattípust. (Típuskonverzió) # Operátorok ## Összehasonlító operátorok ``` Kisebb (<) Nagyobb (>) Kisebb vagy egyenlő (<=) Nagyobb vagy egyenlő (>=) Egyenlő (==) Nem egyenlő (!=) ``` ## Logikai operátorok ``` és (&&) (and) vagy (||) (or) nem (!) (not) (negáció, negation) ``` ## Értékadó operátorok ``` Egyenlő (=) (equals) Például: a = 62 b = 7 ``` ## Rövidítések ```cpp a = a + 1 <=> a += 1 <=> a++ (inkrementálás) a = a - 1 <=> a -= 1 <=> a-- (dekrementálás) a = a * 2 <=> a *=2 ``` # Inkrementáló és dekrementáló műveletek Ha a változó után, vagy a váltózó elé, két darab "+" jelet írunk akkor a változó értéke 1-el nő, ha pedig két darab "-" jelet akkor a változó értéke 1-el csökken. ## Inkrementálás ("a" változóra) ```cpp a++ ++a ``` ## Dekrementálás ("b" változóra") ```cpp b-- --b ``` #### Megjegyzések Ha a két "+" jel (vagy "-") a változó előtt van, akkor az inkrementálás/dekrementálás megtörténik a műveletek elvégzése előtt, viszont ha a változó után, akkor az inkrementálás/dekrementálás akkor a műveletek elvégzése után történik meg. Ha az inkrementáló/dekrementáló művelet előtt más aritmetikai művelet kerül, akkor az inkrementálást/dekrementálást zárójelek közé kell írni. # Feltételes műveletek Alakja C++-ban ``` FELTÉTEL ? MŰVELE_1 : MŰVELET_2 I H ``` Például ```cpp int main() { int x = -20; cout << ((x >= 0) ? "Pozitív" : "Negatív" ) << endl; return 0; } ``` # Matematikai műveletek Ahhoz, hogy matematikai függvényeket tudjunk használni C++-ban azt a fejlécállományt kell használjuk, amelyben a matematikai függvények vannak. Ennek a formája: ```cpp #include ``` #### Fontosabb függvények ```cpp sqrt(X) - négyzetgyök X abs(x) - abszolút érték (modulusz) pow(x, n) - hatványozás (x^n) sin(x) - szinusz X cos(x) - koszinusz X log(x) - természetes alapú logaritmus X ceil(x) - felfele kerekítés floor(x) - lefele kerekítés tan(x) - tangens X acos(x) - arkusz koszinusz X asin(x) - arkusz szinusz X cosh(x) - koszinusz hiperbolikusz X exp(x) - exponenciális függvény log10(x) - 10-es alapú logaritmus X log2(x) - 2-es alapú logaritmus X hypot(x, y,) - derékszögű háromszög átfogójának kiszámítása, ahol x és y befogók fmod(x, y) - osztás maradékának kiszámítása round(x) - kerekítés a legközelebbire ``` # Adatok beolvasása billentyűzetről és kiírása képernyőre Ahhoz, hogy adatokat tudjunk beolvasni és kiírni a képernyőre, az "iostream" fejállomány szükséges.(#include \). Képernyőre kiírni a "cout" segítségével tudunk, melynek szintaxisa a következő: ```cpp cout << KIFEJEZÉS_1 << KIFEJEZÉS_2 << ... << KIFEJEZÉS_n << endl; ``` #### Megjegyzések Ha az utasítás sorozat végére az "endl" szavacskát írjuk, akkor a kiírás után a kurzor új sorba lép. Ha szöveget íratunk ki, akkor azt idézőjelek közé kell írni. Például: ```cpp cout << "A darabszám: " << db << endl; szöveg változó értéke ``` Adatokat bekérni a billentyűzetről a "cin" utasítással lehet, melynek szintaxisa a következő: ```cpp cin >> KIFEJEZÉS_1 >> KIFEJEZÉS_2 >> ... >> KIFEJEZÉS_n; ``` #### Szabály (szubjektív) Minden beolvasás előtt ki kell íratni szöveggel egy utasítást arra vonatkozóan, hogy mit szeretnél, hogy a felhasználó beírjon a billentyűzetről. # Döntések (elágazások, szelekciók) ## Az if utasítás Az if utasítás segítségével 1, illetve kétágú döntéseket hozhatunk létre a programban. #### Általános alakja (kétágú döntés) ```cpp if ( FELTÉTEL ) { UTASÍTÁSOK_1; } else { UTASÍTÁSOK_2; } ``` #### Megjegyzések Először kiértékelődik a feltétel, ha a feltétel nem 0, vagyis igaz, akkor végrehajtódnak az if utáni utasítások, ha a feltétel pedig hamis akkor az else utáni utasítások hajtódnak végre. Ha valamelyik ágon csak egyetlen utasítás van, akkor ott a kapcsos zárójelet elhagyhatjuk. A feltételt kötelezően mindig zárójelek () közé kell írni és nem teszünk pontosvesszőt a végére! Ha a feltétel összetett, akkor a feltétel részeit külön-külön még zárójelek közé írjuk. #### Általános alakja (egyágú döntés) ```cpp if( FELTÉTEL ) { UTASÍTÁSOK; } ``` #### Megjegyzések Úgy kaptuk az egyágú döntést, hogy a kétágú döntésből elhagytuk az else ágat. Ide ugyan azok a szabályok érvényesek, mint a kétágú döntésnél. Egy- és kétágú döntések egymásba ágyazásával többágú döntéseket hozhatunk létre. ### Példaprogram ```cpp #include using namespace std; int main() { float sz1, sz2, h1, h2; float T1, T2; cout << "sz1: "; cin >> sz1; cout << "h1: "; cin >> h1; cout << "sz2: "; cin >>sz2; cout << "h2: "; cin >> h2; T1 = sz1 * h1; T2 = sz2 * h2; if(T1 > T2) { cout << "A legnagyobb terület: " << T1 << endl; } else { cout << "A legnagyobb terület: "; << T2 < using namespace std; int main() { char c; cout << "Adj meg egy római karaktert: "; cin >> c; switch(c) { case 'I': { cout << "1"; break; } case 'V': { cout << "5"; break; } case 'X': { cout << "10"; break; } case 'L': { cout << "50"; break; } case 'C': { cout << "100"; break; } case 'D': { cout << "500"; break; } case 'M': { cout << "1000"; break; } default: { cout << "Te, ez nem római számjegy!"; } } } ``` # A for utasítás (számlálós ciklus) #### Általános alakja C++-ban ```cpp for ( KEZDETI_ÉRTÉKADÁS ; FOLYTATÓDÁSI_FELTÉTEL ; MÓDOSÍTÓ_KIFEJEZÉS) { UTASÍTÁSOK; } ``` A for ciklus úgy működik, hogy általában egy ciklusváltozót használunk melynek a kezdeti értékadás során kezdőértéket adunk. Ez után beállítjuk a folytatási feltételt. Ha a folytatási feltétel teljesül, akkor végrehajtódnak a ciklus utasításai (megtörténik az iteráció) és a módosító kifejezés segítségével a ciklusváltozó automatikusan változik. A módosítás legtöbbször a ciklusváltozó 1-el való növekedését jelenti (ekkor növekvő ciklusról beszélünk), de csökkenthetjük is a ciklusváltozót (ekkor csökkenő ciklusról beszélünk). ### Példa program ```cpp #include using namespace std; int main() { for(short i = 1; i <= 100; i++) { cout << i << " "; } } ``` # A while utasítás Programozás során találkozunk olyan helyzetekkel, amikor ugyanazt az utasításokat többször végre kell hajtsa a program, viszont a végrehajtások (iterációk) számát előre nem ismerjük, azaz nem használhatunk számlálós ciklust. Az ismétlődések száma viszont függ egy feltételtől és ennek teljesülésekor következik be az ismétlődés. Ezeket a ciklusokat feltételes ciklusoknak is nevezzük. Ha a ciklus feltétele a ciklus utasításai előtt helyezkedik el, akkor elöltesztelő ciklusról beszélünk. Az elöltesztelő ciklusnak megfelelő utasítás a while utasítás, melynek általános alakja a következő: ```cpp while( FELTÉTEL ) { UTASÍTÁSOK; } ``` Először kiértékelődik a feltétel, ha ennek logikai értéke igaz, akkor végrehajtódnak a ciklus utasításai, különben a vezérlés átadódik a ciklus utáni első műveletnek. Vigyáznunk kell arra, hogy a ciklus utasításai olyanok legyenek, hogy bizonyos számú ismétlődés után a feltétel hamissá váljon, különben a ciklus végtelen ciklussá válik és hibaüzenettel a program leáll. Az is előfordulhat, hogy a feltétel már az első pillanatban hamis, ilyenkor egyszer sem hajtódnak végre a ciklus utasításai, azaz nem történik meg az iteráció. A feltétel kifejezését kötelezően kerek zárójelek () közé kell írni, ha a ciklus csak egy utasítást tartalmaz, akkor azt nem kötelező kapcsos zárójelek {} közé írni. Kettő vagy annál több utasítás esetén viszont kötelező a kapcsos zárójelek {} használata, különben csak az első utasítást hajtja végre a ciklus. Egy másik hiba, hogy pontosvesszőt (;) teszünk a feltételt követő zárójel után, melynek következtében nem tudnak végrehajtódni a ciklus utasításai így hibás programhoz jutunk. Sok esetben több számot kell bevinnünk billentyűzetről. Ha előre ismerjük, hogy hány számot kell bevinni akkor számlálós ciklust használunk, ha viszont nem tudjuk, akkor végjelig történik a számok bevitele. ### Példa program ```cpp #include using namespace std; int main() { int n; int s = 1; cout <<"n: "; cin >> n; while(n != 0) { s *= n; cin >> n; } cout << s; } ``` # A do ... while ciklus A do...while utasítás a hátultesztelő ciklusnak megfelelő C++ béli utasítás. Hátultesztelő ciklus esetén a ciklus feltétele a ciklus után helyezkedik el. Általános alakja: ```cpp do { UTASÍTÁSOK; } while ( FELTÉTEL ); ``` A do...while utasítás a while utasítással ellentétben úgy működik, hogy először mindenképp végrehajtódnak a műveletek, majd csak utána értékelődik ki a feltétel. Ha a feltétel igaz, akkor megtörténik az ismétlődés, viszont ha hamis akkor a vezérlés átadódik a ciklus utáni első utasításnak. Akárcsak az elöltesztelő ciklusnál, vigyáznunk kell arra, hogy a ciklus feltétele hamissá váljon, különben végtelen ciklushoz jutunk. A feltételeket kötelező kerek zárójelek () között megadni. Ha a ciklusban kettő vagy több utasítás szerepel, akkor ezeket kötelező kapcsos zárójelek {} közé írni. Az utasításokat követő feltétel zárójele után mindig pontosvesszőt (;) kell tenni. Leggyakrabban a do...while ciklust a beviteli adatok ellenőrzésére szoktuk használni (hibás adatok kiküszöbölésére) . # Szöveges állományok Az eddigi munkánk során az értékeket billentyűzetről vittük be és egy bizonyos ablakba kaptuk az eredményt, így a beírt és kiírt értékek elvesznek. Ezt a problémát kiküszöbölhetjük úgy, hogy a be- és kimeneti adatokat a szöveges állományokból vesszük ki, illetve szöveges állományokba íratjuk ki, így a későbbiek során bármikor elérhetőek lesznek. A szöveges állományok használata akkor is nagyon előnyös, amikor egy programot többször is leszeretnénk futtatni ugyanazokra az értékekre. Ebben az esetben ,ha bemeneti adatok egy szöveges állományban vannak tárolva, akkor a program automatikusan onnan olvassa ki a bemeneti értékeket és nem szükséges minden futtatáskor nekünk bekérni. A szöveges állományok létrehozhatók egy egyszerű szövegszerkesztővel (Jegyzettömb, Notepad++, Sublime Text, ...), utána meg egyszerűen módosíthatók. A szöveges állományok kiterjesztése, a .txt-n kívül, megváltoztathatóak a .in, .out, .stb... kifejezésekre. A szöveges állományokat csak szekvenciálisan lehet használni, ami azt jelenti, hogy a szöveges állomány adatait csak egymás utáni sorrendben lehet elérni (csak az állomány elejétől a vége fele tudunk olvasni, mindig a legelső karaktert tudjuk elérni elsőként, tehát nem lehet az állományt középről olvasni egyből). Az állományok kezelése 3 nagy lépésre osztható: * Az állomány megnyitása * Az állomány feldolgozása * Az állomány bezárása ## Az állomány megnyitása Ahhoz, hogy állományokkal dolgozni tudjunk, ahhoz be kell építsünk az "fstream" nevű fejlécfájlt. ```cpp #include < fstream > ``` Állományok megnyitása során figyelembe kell vennünk azt, hogy meglévő állományt, vagy esetleg új állományt akarunk megnyitni, ennek függvényében 3 esetet különböztetünk meg: * Létező (bemeneti) állomány megnyitása olvasás céljából * Új (kimeneti) állomány megnyitása * A fájlok bezárása ### Létező (bemeneti) állomány megnyitása olvasás céljából Fájlból olvasáshoz először is létre kell hozni egy bemeneti adatállomány típusú fájlváltozót, ezután meg kell nyitni az állományt. Ekkor jöhet az állomány hozzárendelése a fájl változóhoz. Megnyitás után az állománymutató az állomány elején fog elhelyezkedni. ```cpp ifstream FÁJLVÁLTOZÓ; FÁJLVÁTOZÓ.open( "FÁJLNÉV.KITERJESZTÉS" ); ``` Ha az állomány nem a program aktuális könyvtárában van, akkor a fájlnév előtt meg kell adni az elérési útvonalat is. #### Megjegyzések A deklarálást és megnyitást összevonhatjuk egy sorba. ```cpp ifstream FÁJLVÁLTOZÓ( "FÁJLNÉV.KITERJESZTÉS" ); ``` ### Új (kimeneti) állomány megnyitása Új állományt csak akkor tudunk létrehozni, ha először deklarálunk egy kimeneti adatállomány típusú változót, majd társítjuk egy fizikai állománynévhez, mely létre fog jönni és megnyitódik. ```cpp ofstream FÁJLVÁLTOZÓ; FÁJLVÁLTOZÓ.open( "FÁJLNÉV.KITERJESZTÉS" ); ``` #### Megjegyzések Vigyáznunk kell ezzel az utasítással, hiszen ha a meglévő állományt nyitjuk meg újként akkor az állomány tartalma elveszik. ### Írás és olvasás állományokból Állományból beolvasni a standard beolvasáshoz hasonlóan lehet. Ha másképpen nem állítjuk, akkor szóköztől szóközig olvas a program és ezek az adatok kerülnek a megadott változókba. ```cpp FÁJLVÁLTOZÓ >> VÁLTOZÓ_1 >> VÁLTOZÓ_2 >> ... >> VÁLTOZÓ_n; ``` Állományba írni szintén a standard kiíratáshoz hasonlóan lehet. ```cpp FÁJLVÁLTOZÓ << KIFEJEZÉS_1 << KIFEJEZÉS_2 << ... << KIFEJEZÉS_n (<< endl); ``` ### A fájlok bezárása A megnyitott fájlokat a következőképpen tudjuk bezárni: ```cpp FÁJLVÁLTOZÓ.close(); ``` #### Megjegyzések A fájlokat kötelezően be kell zárni a feldolgozás után. # Egydimenziós tömbök Programozás során találkozhatunk olyan feladatokkal, amelyek megoldása során több azonos típusú adatot kell tároljon. Az eddig használt tárolási mód erre nem célszerű, hiszen ha több száz egész számot szeretnénk tárolni akkor több száz változóra van szükségünk. Az ilyen típusú adatok tárolására alkalmasak a tömbök. A tömb tehát egy olyan adatszerkezet amely egy rögzített számú, azonos típusú elemekből épül fel. Az elemeket a tömbön belül az indexeik segítségével azonosíthatjuk. A tömb a memóriában lineárisan van tárolva, hasonlít egy olyan fiókra amely több rekeszre van felosztva. Nevet csak a "fióknak" adunk, a "rekeszeket" meg megszámozzuk (indexeljük). ![](https://2370504955-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-LNeGjFVCqq0MtkPhjib%2F-LNkrIZ1Ntrf_pyK0e0h%2F-LNkrtCLJfaTQiVcnS-G%2Fvektor_1.png?alt=media\&token=6f41b643-7e6c-4a34-8946-45bfcccbb078) #### Megjegyzések A C++ nyelvben az indexelés automatikus. Az első elem mindig 0. elem (0-s indexel rendelkezik). Az egydimenziós tömböket vektoroknak is nevezzük. Deklarálása a következő: ```cpp ELEMTÍPUS TÖMBVÁLTOZÓ_NEVE [ TÖMBMÉRET ]; ``` Az elemtípusnál határozzuk meg, hogy a tömb milyen adattípusú elemeket tartalmazhat, a tömbméret pedig a tömbben tárolható maximális elem darabszámait jelenti. #### Egydimenziós tömbök inicializálása ```cpp int a[4] = {2, 4, -1, 6}; ``` | Elem | 2 | 4 | -1 | 6 | | ----- | - | - | -- | - | | Index | 0 | 1 | 2 | 3 | Azt is megtehetjük, hogy nem inicializáljuk (adunk értéket) a tömb összes elemét, ilyenkor a compiler automatikusan 0 kezdőértékkel látja el a nem inicializált elemet. ```cpp int b[6] = {-7, 7, 8}; ``` | Elem | -7 | 7 | 8 | 0 | 0 | 0 | | ----- | -- | - | - | - | - | - | | Index | 0 | 1 | 2 | 3 | 4 | 5 | Ha ismerjük inicializáláskor a tömb összes elemét akkor nem muszály tömbméretet megadni, hiszen automatikusan annyi lesz ahányat felsoroltunk. ```cpp int c[] = {2, 7, 8}; ``` # Egydimenziós tömb feltöltése billentyűzetről Egy tömb elemeti nem lehet egyszerre beolvasni. Először beolvassuk az elemek tényleges számát, majd egy számlálós (for) ciklussal beolvassuk egyenként az elemeket. ```cpp int v[100]; int n; cout << "Add meg a tömb méretét: "; cin >> n; for ( int i = 0; i < n; i++ ) { cout << "v[" << i << "]: "; cin >> v[i]; } ``` Megtehetjük azt is, hogy egyszer beolvassuk az elemek számát és utána a deklaráljuk a tömböt a megadott elemszámmal. ```cpp int n; cout << "Add meg a tömb méretét: "; cin >> n; int v[n]; ``` # Egydimenziós tömb kiíratása képernyőre A képernyőre való kiiratás egy számlálós (for) ciklus segítségével történik. ```cpp ... for (int i = 0; i < HOSSZ; i++) { cout << v[i] << " "; } ... ``` #### Megjegyzés Az "iomanip" nevű fejlécállományban használható a setw() függvény ami segítségével tagoltabbá tudjuk tenni a tömb kiiratását. ```cpp ... for (int i = 0; i < HOSSZ; i++) { cout << setw(4) << v[i]; } ... ``` # Kétdimenziós tömbök A kétdimenziós tömb szintén egy olyan adatszerkezet amely rögzített számú azonos típusú elemből épül fel. Abban külömbözik az egydimenziós tömbtől, hogy az elemek nem csak sorokba, hanem oszlopokba is vannak rendezve. Kiváló példa a kétdimenziós tömbök szemléltetésére a sakktábla vagy a tojástartó rács. A kétdimenziós tömböt mátrixoknak is szokták nevezni (matematikából kiindulva). A mátrix sorait sorindexek határozzák meg, az oszlopait pedig oszlopindexek azonosítják. A sorok és oszlopok indexelése akárcsak az egydimenziós tömböknél automatikusan 0-tól kezdődik. A fenti gondolatmenetet tovább folytatva újabb indexek meghatározásával három vagy annál többdimenziójú tömböket is létre tudunk hozni. #### Mátrix deklarálása Mátrixot úgy tudunk deklarálni, hogy az elemtípus és a tömbváltozó meghatározása után megkell adnunk először a sorindex, majd az oszlopindex felső határait a következő szintaxissal: ```cpp ELEMTÍPUS VÁLTOZÓ[SOROK SZÁMA] [OSZLOPOK SZÁMA] Pl: int m[3][2] = {}; /** Akárcsak a vektoroknál, itt is érvényes az, hogy a nem inicializált elemet automatikusan 0 kezdőértékkel látja el. **/ ``` | m | **0** | **1** | | ----- | ----- | ----- | | **0** | 0 | 0 | | **1** | 0 | 0 | | **2** | 0 | 0 | # Kétdimenziós tömbök feltöltése billentyüzetről Mint a vektoroknál, itt sem lehet egyszerre beolvasni a mátrix értékeit. Először beolvassuk a sorok és oszlopok számát majd két egymásba ágyazott számlálós (for) ciklus segítségével beolvassuk egyenként az elemeket. ```cpp int n, m; cout << "A sorok száma: "; cin >> n; cout << "Az oszlopok száma: "; cin >> m; int A[n][m]; for ( int sor = 0; sor < n; sor++ ) { for (int oszlop = 0; oszlop < m; oszlop++ ) { cout << "A[" << sor << "][" << oszlop << "]: "; cin >> A[sor][oszlop]; } } ``` # Kétdimenziós tömbök kiíratása képernyőre A beolvasáshoz hasonlóan történik, csak a kiiratás részét hagyjuk meg. ```cpp int n, m; cout << "A sorok száma: "; cin >> n; cout << "Az oszlopok száma: "; cin >> m; int A[n][m]; for ( int sor = 0; sor < n; sor++ ) { for (int oszlop = 0; oszlop < m; oszlop++ ) { cout << "A[" << sor << "][" << oszlop << "]: "; } } ``` # Logo Icons made by [Smashicons](https://www.flaticon.com/authors/smashicons) from [www.flaticon.com](https://www.flaticon.com/) is licensed by [CC 3.0 BY](http://creativecommons.org/licenses/by/3.0/)