Jegyzet
Készítette: Groff Tamás 1
Tartalomjegyzék Az operátorok precedenciája és asszociativitása Adattípusok Programfejlesztés lépései Kiíratás Függvények használata 1. Függvények használata 2. Típusok méretei Változók használata Csomag és típus meghatározása előre Túlcsordulás Állandók Összetett utasítás és kifejezések használata Alapműveletek Prefix és postfix használata Precedencia, avagy a műveletek végrehajtási sorrendje Relációs operátorok és az if … else … elágazás Összetett if szerkezet Logikai operátorok Függvények deklarálása, definiálása és használata Helyi és globális változók Helyi változók és az argumentumátadás Függvény a függvényben Értékek visszaadása a függvényből Függvények alapértelmezett paraméterei Függvények túlterhelése Inline függvények Gyakorlás (Celsius és Fahrenheit közötti átváltás) While ciklus Bonyolultabb while ciklus A continue és a break Végtelen ciklus a while segítségével A do … while ciklus A for ciklus Halmozott inicializáció és léptetés a for ciklusban Üres utasítások a for ciklusfejben Üres for ciklusfej Üres for ciklusmag Egymásba ágyazott ciklusok 1. A switch utasítás Valós típusú ciklusváltozó használata Egymásba ágyazott ciklusok 2. Ciklus a switch ágában Kilépés csak
gombbal Új osztály létrehozása és használata
5. 6. 7. 7. 7. 8. 8. 9. 9. 10. 11. 11. 12. 12. 13. 13. 14. 15. 16. 16. 17. 18. 19. 20. 20. 21. 22. 23. 23. 24. 25. 25. 26. 26. 27. 27. 28. 28. 29. 29. 30. 31. 31. 32.
2
Konstruktorok és destruktorok, avagy az objektum létrehozása ás törlése Több példány használata a Cat osztályból Fejlécállományok használata 1. Fejlécállományok használata 2. Kilépés csak <ENTER> gombbal Memóriacím kiírása Mutatók használata Adatváltoztatás mutatók használatával A mutatókban tárolt címek vizsgálata Memóriafoglalás és mutatók törlése A memóriaszivárgás elkerülése Objektumok létrehozása és törlése a dinamikusan kezelt memóriában Adattagok elérese mutatókon keresztül Adattagok a dinamikus memóriában Magyar karakterek használata a programban A this mutató Konstans mutatók és konstans tagfüggvények Egy dimenziós tömb használata Egy dimenziós tömb bejárása Összegzés, eldöntés és kiválasztás tétele Összegzés, eldöntés és kiválasztás tétele a dinamikus memóriában Lineáris keresés, megszámlálás, kiválogatás, maximum-kiválasztás és minimum-kiválasztás tétele Metszetképzés és unióképzés tétele Minimum-kiválasztásos, maximum-kiválasztásos, buborék és beszúrásos rendezés Kétdimenziós tömb (mátrix) használata N dimenziós tömb használata Véletlenszám generálás Gyakorlás (Számkitalálos játék) Vektorok használata Végjelig történő beolvasás 1. Végjelig történő beolvasás 2. Vektorok feltöltése végtelenszámokkal végjelig cmath függvények használata Címszerinti paraméterátadás Prím-e? Faktoriális számítása Várakozás és a képernyő törlése String és char alapok A string karaktereihez való hozzáférés String függvények használata 1. Zárójelek megfelelő használatának vizsgálata Monogramm készítés String függvények használata 2. Input String Stream és Output String Stream 1. Input String Stream és Output String Stream 2.
33. 34. 35. 37. 40. 40. 40. 41. 42. 42. 43. 44. 45. 45. 46. 46. 47. 48. 49. 49. 50. 52. 54. 57. 60. 60. 61. 62. 62. 63. 63. 64. 65. 65. 66. 67. 67. 68. 68. 69. 70. 71. 71. 73. 74.
3
Fájlkezelés 1. Fájlkezelés 2. string to int, int to string Dátum és idő lekérdezése és használata GotoXY és a színes betűk használata Pénzügyi helyzet kiértékelése Saját függvények használata Kétdimenziós vektor használata Beep használata Hivatkozások használata Címe operátor és a hivatkozás operátor Cím szerinti paraméterátadás mutatókkal Cím szerinti paraméterátadás hivatkozásokkal Több érték visszaadása Osztályok és objektumok használata Private változó használata az osztályban Objektum Orientált Programozás Konstans mutató átadása függvényben Konstans hivatkozások átadása függvényben Mutató, mint a függvény visszatérési értéke Alapértelmezett értékek, túlterhelt tagfüggvények és konstruktorok A másoló konstruktor Saját prefix és postfix operátorok használata Az összeadás (+) és a különbség (-) operátor túlterhelése A hozzárendelési (=) és az egyenlőség (==) operátor túlterhelése A konverziós operátor és az int() operátor Objektumtömbök kezelése Többdimenziós tömb kezelése Mutatótömbök használata Tömb létrehozása a dinamikus memóriában Karaktertömbök használata Az strcpy_s() függvény használata Az strncpy_s() és strcat_s() függvény használata Tovább Tovább Tovább Tovább
74. 75. 76. 76. 77. 78. 79. 80. 81. 81. 81. 82. 82. 83. 84. 84. 85. 86. 87. 88. 89. 90. 92. 93. 94. 95. 96. 96. 97. 98. 99. 99. 99. 100. 100. 100. 100.
4
Az operátorok precedenciája és asszociativitása Szint
Művelet
Használat
1
hatókör-feloldás hatókör-feloldás globális hatókör globális hatókör
osztálynév :: tag névtér_név :: tag :: név :: minősített_név
2
tagkiválasztás tagkiválasztás indexelés függvényhívás érték létrehozása növelés utótaggal csökkentés utótaggal típusazonosítás futási idejű típusazonosítás futási időben ellenőrzött típuskényszerítés fordítási időben ellenőrzött típuskényszerítés nem ellenőrzött típuskényszerítés konstans típuskényszerítés
objektum . tag mutató -> tag mutató [kif] kif (kif_lista) típus (kif_lista) balérték++ balérték-typeid (típus) typeid (kif) dynamic_cast (kif) static_cast (kif) reinterpret_cast (kif) const_cast (kif)
3
objektum mérete típus mérete növelés előtaggal csökkentés előtaggal komplemensképzés (logikai) nem mínusz előjel plusz előjel cím operátor indirekció létrehozás (memóriafoglalás) létrehozás (memóriafoglalás és kezdeti értékadás) létrehozás (elhelyezés) létrehozás (elhelyezés és kezdeti értékadás) felszámolás (felszabadítás) tömb felszámolása típuskonverzió
sizeof kif sizeof (típus) ++balérték --balérték ~ kif ! kif - kif + kif & balérték * kif new típus new (kif_lista) new (kif_lista) típus new (kif_lista) típus (kif_lista) delete mutató delete [ ] mutató (típus) kif
4
tagkiválasztás tagkiválasztás
objektum .* tagra_hivatkozó_mutató mutató ->* tagra_hivatkozó_mutató
5
szorzás osztás moduló (maradékképzés)
kif * kif kif / kif kif % kif
6
összeadás (plusz) kívonás (mínusz)
kif + kif kif - kif
7
balra léptetés jobbra léptetés
kif << kif kif >> kif
5
Szint
Művelet
Használat
8
kisebb kisebb vagy egyenlő nagyobb nagyobb vagy egyenlő
kif < kif kif <= kif kif > kif kif >= kif
9
egyenlő nem egyenlő
kif == kif kif != kif
10
bitenkénti ÉS
kif & kif
11
bitenkénti kizáró VAGY
kif ^ kif
12
bitenkénti megengedő VAGY
kif | kif
13
logikai ÉS
kif && kif
14
logikai megengedő VAGY
kif || kif
15
feltételes kifejezés
kif ? kif : kif
16
egyszerű értékadás szorzás és értékadás osztás és értékadás maradékképzés és értékadás összeadás és értékadás kivonás és értékadás balra léptetés és értékadás jobbra léptetés és értékadás ÉS és értékadás megengedő VAGY és értékadás kizáró VAGY és értékadás
balérték = kif balérték *= kif balérték /= kif balérték %= kif balérték += kif balérték -= kif balérték <<= kif balérték >>= kif balérték &= kif balérték |= kif balérték ^= kif
17
kivétel kiváltása
throw kif
18
vessző (műveletsor)
kif , kif
Adattípusok Típus
Méret
Tartomány
unsigned short (int) (signed) short (int) unsigned long (int) (signed) long (int)
2 byte 2 byte 4 byte 4 byte 2 byte vagy 4 byte 2 byte vagy 4 byte 2 byte vagy 4 byte 1 byte 2 byte 1 byte 4 byte 8 byte 10 byte
0-tól 65.535-ig -32.768-tól +32.767-ig 0-tól 4.294.967.295-ig -2.147.483.648-tól +2.147.483.647-ig 0-tól 65.535-ig vagy 0-tól 4.294.967.295-ig -32.768-tól +32.767-ig vagy -2.147.483.648-tól +2.147.483.647-ig 0-tól 65.535-ig vagy 0-tól 4.294.967.295-ig 256 karakter 65.535 karakter True vagy False -38 38 1,2*10 -tól 3,4*10 -ig -308 308 2,2*10 -tól 1,8*10 -ig -4932 4932 3,4*10 -tól 1,1*10 -ig
unsigned int
(signed) int
size_t char wchar_t bool float double long double
6
Kiíratás
Programfejlesztés lépései
//ez egy 1 soros megjegyzés //az include egy parancs, ami jelzi, hogy egy fájlnevet adok meg //a # az előfeldolgozó (preprocessor) számára jelez #include "stdafx.h" //ez a visual studiohoz kell #include //beemeljük az iostream nevű fájlt a programunkba //a program nem vesszi figyelembe a kihagyott sorokat int main() //a program futása a main függvényben kezdődik, //ezért a main minden programban kötelező { //minden függvény törzsének { } között kell lennie //a << az átírányítást jelképezi std::cout << "Hello World\n"; //a stringet "így" adjuk meg //a cout a képernyőre kiírás utasítása, amit az std "csomagban" találunk meg //a sor végén lévő \n az újsor kezdését jelöli (sort ugrik) std::cout << "Kilepeshez nyomjon <ENTER> gombot! "; //nem lehet magyar ékezetet használni std::cin.get(); //vár az ENTER megnyomására, így nem lép ki egyből //a cin a bekérés utasítása, amit az std "csomagban" találunk meg return 0; //egy értéket ad vissza a return, //ez most int típusú, mivel a main is kötelezően int típusú } //ez a main függvény vége //A hibaüzenet azt jelenti, hogy a fordító a forráskódunkat //nem tudja gépi kóddá alakítani. //A figyelmeztetés azt jelenti, hogy sikerült ugyan lefordítani, //de nem biztos, hogy úgy, ahogyan mi szerettük volna. //Van egy harmadik lehetőség is, amikor a programunkban logikai hiba keletkezik, //ilyenkor létrejön az .exe, de nem úgy működik, ahogy szerettük volna. /* ez egy többsoros megjegyzés */ //ez C++ típusú /*ez meg C típusú megjegyzés*/ //C típusú megjegyzésen belül nem lehet még 1 C típusú, de C++ típusú akármennyi
Függvények használata 1. #include "stdafx.h" //ez a visual studiohoz #include //függvényhívás bemutatása //üzenet megjelenítése a képernyőn void kiirat() //a visszatérési értéke void, vagyis nincs visszatérési értéke, így olyan mint egy eljárás { std::cout << "A kiirat fuggvenyben vagyunk!\n"; } //a main() függvény - kiír egy üzenetet, meghívja a kiírat nevű függvényt, és kiír egy másik üzenetet int main() //a main() mindig int visszatérési értékű { std::cout << "A main fuggvenyben vagyunk!\n"; kiirat(); //így hívom meg az "eljárást" std::cout << "Ismet a main-ben vagyunk!\n\n"; //több \n is lehet egymás után std::cout << "Kilepeshez nyomjon <ENTER> gombot! "; std::cin.get(); //vár az ENTER megnyomására, így nem lép ki egyből return 0; //a main() visszatérési értéke, ez az operációs rendszernek szól }
7
Függvények használata 2. #include "stdafx.h" //ez a visual studiohoz #include int Add(int x, int y) //2 egész típusú bemenete és 1 egész típusú kimenete van { std::cout << "\nItt az Add() fuggveny, a kovetkezo erteket kaptam " << x << " es " << y << "\n"; return(x + y); } int main() { std::cout << "A main fuggvenyben vagyunk!\n"; std::cout << "Meghivjuk az Add() fuggvenyt\n"; //string elején is lehet a sor ugrás std::cout << "A visszaadott ertek: " << Add(3,4); //így hívhatom meg a függvényt std::cout << "\n\nIsmet a main() fuggvenyben vagyunk!\n"; std::cout << "Kilepunk..."; std::cin.get(); //vár az ENTER megnyomására return 0; }
Típusok méretei #include "stdafx.h" //ez a visual studiohoz #include //ez csak így müködik, emígy nem: , "iostream.h" int main() { std::cout << "Hello\nWord\n"; //egyszerre két sort is kiírhatok std::cout << ".\t.\n"; std::cout << ".\t.\n"; std::cout << ". .\n"; //itt a \t egyenlő 7 szóközzel std::cout << ".\t.\n"; std::cout << ".\t.\n\n"; //gyakran használt típusok méretei std::cout << "Egy int tipusu valtozo merete:\t\t"; std::cout << sizeof(int) << " byte.\n"; //a sizeof az átadott objektumtípus méretét adja vissza std::cout << "Egy short tipusu valtozo merete:\t"; std::cout << sizeof(short) << " byte.\n"; std::cout << "Egy long tipusu valtozo merete:\t\t"; std::cout << sizeof(long) << " byte.\n"; std::cout << "Egy char tipusu valtozo merete:\t\t"; std::cout << sizeof(char) << " byte.\n"; std::cout << "Egy bool tipusu valtozo merete:\t\t"; std::cout << sizeof(bool) << " byte.\n"; std::cout << "Egy float tipusu valtozo merete:\t"; std::cout << sizeof(float) << " byte.\n"; std::cout << "Egy double tipusu valtozo merete:\t"; std::cout << sizeof(double) << " byte.\n"; //most kilépünk std::cout << "\nKilepunk..."; std::cin.get(); //vár az ENTER megnyomására return 0; }
8
Változók használata #include "stdafx.h" #include int main() { int MyAge; //így deklarálunk egy változót MyAge = 18; //legyen a MyAge értéke 18 std::cout << "MyAge erteke: " << MyAge << "\n"; unsigned short /*int*/ myAge; //pontosan meghatározzuk a változó típusát, méretét //az unsigned azt jelenti hogy előjel nélküli myAge = 18; std::cout << "myAge erteke: " << myAge << "\n"; //a C++ megkülönbözteti a MyAge és a myAge változót //próbáljunk meg olyan neveket választani, ami utal a tárolt adatra unsigned short a, b, t; //3(a,b,t) változó deklarálása egyszerre a = 4; b = 5; t = a * b; //t értéke legyen a * b, ez a téglalap területe std::cout << "A teglalap ket oldala: " << a << " es " << b << "\n"; std::cout << "A teglalap terulete: " << t << "\n"; unsigned short k = 0; //deklarálásnál kezdőértéket adhatunk k = 2 * (a + b); std::cout << "A teglalap kerulete: " << k << "\n"; unsigned short int Width = 5, Length; /*az előbbi ezzel a 3 sorral egyezik meg: unsigned short int Width; Width = 5; unsigned short int Length;*/ Length = 10; unsigned short int Area = Width * Length; //készítek egy előjel nélküli egész változót, //kezdőértékként a szélesség és a hosszúság szorzatával feltöltve std::cout << "Szelesseg: " << Width << "\n"; std::cout << "Hosszusag: " << Length << std::endl; //az std::endl sortörést jelent std::cout << "Terulet: " << Area << std::endl; std::cout << "\nKilepunk..."; std::cin.get(); //vár az ENTER megnyomására return 0; }
Csomag és típus meghatározása előre #include "stdafx.h" #include using namespace std; //ez arra szolgál, hogy nem kell mindig beírni az „std::” karaktereket a cout, cin, endl parancsok elé typedef unsigned short USHORT; //typedef meghatározása könnyebb deklaráláshoz
9
int main() { USHORT Width = 5; USHORT Length; Length = 10; USHORT Area = Width * Length; cout << "Szelesseg: " << Width << endl; cout << "Hosszusag: " << Length << endl; cout << "Terulet: " << Area << endl; cout << "\nKilepunk..."; cin.get(); //vár az ENTER megnyomására return 0; }
Túlcsordulás #include "stdafx.h" #include using namespace std; typedef unsigned short USHORT; typedef signed short ESHORT; int main() { USHORT smallNumber; smallNumber = 65535; //ha túl nagy értéket akarunk benne tárolni, akkor hibás lesz, //mert körbefordul úgy, mint az autón a kilométer óra cout << "small number: " << smallNumber << endl; smallNumber++; //smallNumber = smallNumber + 1; cout << "small number: " << smallNumber << endl; smallNumber++; cout << "small Number: " << smallNumber << endl; ESHORT smalNumber; smalNumber = 32767; //amikor kifutunk a pozitív számokból, rögtön a legnagyobb negatív számra ugrunk, //és innen számolunk visszafele nulláig cout << endl << "smal number: " << smalNumber << endl; smalNumber++; cout << "smal number: " << smalNumber << endl; smalNumber++; cout << "smal number: " << smalNumber << endl; cout << "\nKilepunk..."; cin.get(); //vár az ENTER megnyomására return 0; }
10
Állandók #include "stdafx.h" #include using namespace std; typedef unsigned short USHORT; //#define osztalyletszam 15 //ez a régi, elavult C nyelvben található, de már nem használjuk const USHORT OSZTALYLETSZAM = 15; //ez már újabb, itt a típust is megkell adni //az állandók nevét célszerű csupa nagy betűvel írni, így egyből látható hogy az állandó enum SZIN { PIROS=100, KEK, ZOLD=500, FEHER, FEKETE=700 }; //ez egy felsorolt állandó, aminek vannak nevesített állandói //PIROS=100, KEK=101, ZOLD=500, FEHER=501, FEKETE=700 int main() { USHORT tanulok = 0, osztalyok = PIROS; //a PIROS nevű állandót használom kezdőértékadásnál, ami egyenlő 100-al tanulok = osztalyok * OSZTALYLETSZAM; cout << "Az iskolaba " << tanulok << " tanulo jar!\n"; cout << "\nKilepunk..."; cin.get(); //vár az ENTER megnyomására return 0; }
Összetett utasítás és kifejezések használata #include "stdafx.h" #include using namespace std; typedef unsigned short USHORT; const USHORT SecondPerMinute = 60; int main() { USHORT tort = 0; tort = 5.4; //itt csonkítás történik, mert az egész típusba csak az egész részt rakja bele cout << "A csonkolt tort: " << tort << endl; USHORT a, b, csere; a = 3; b = 5; cout << "Az a erteke: " << a << endl; cout << "A b erteke: " << b << endl; cout << "Most megcsereljuk a kettot!" << endl; { //ez egy példa az összetett utasításra, itt 1 blokkokat használunk csere = a; a = b; b = csere; } cout << "A a erteke: " << a << endl; cout << "A b erteke: " << b << endl; //kifejezések használata a programban cout << "Ez egy ertek: " << 3.2 << endl; //a PI nem található, mert nem csatoltuk a Math fájlt cout << "Ez a PI allando erteke: " <
11
cout << "\nKilepunk..."; cin.get(); //vár az ENTER megnyomására return 0; }
Alapműveletek #include "stdafx.h" #include using namespace std; typedef unsigned short USHORT; int main() { //többszörös értékadás és művelet együtt, felhasználom az előző változókat (a, b, csere, tort) USHORT a = 5, b = 4, x = 0, y = 0, k = 0; cout << "a:" << a << " b:" << b << " x:" << x << " y:" << y << " k:" << k << endl; cout << "Elvegzendo muvelet: b = 2 * (k = a + (y = x = a + b));" << endl; b = 2 * (k = a + (y = x = a + b)); //zárójeleket kell használni, hogy jól működjön cout << "a:" << a << " b:" << b << " x:" << x << " y:" << y << " k:" << k << endl << endl; x = 3; //kezdőértéket állítok be cout << "x erteke: " << x << endl; x = x + 2; //x legyen x(3)+2 összege cout << "x erteke: " << x << endl; x += 2; //x legyen 2-vel nagyobb cout << "x erteke: " << x << endl; x -= 3; //x legyen 3-mal kissebb cout << "x erteke: " << x << endl; x *= 2; //x legyen kétszer annyi cout << "x erteke: " << x << endl; x %= 3; //x/8 maradéka cout << "x erteke: " << x << endl; cout << "\nKilepunk..."; cin.get(); //vár az ENTER megnyomására return 0; }
Prefix és postfix használata #include "stdafx.h" #include using namespace std; typedef unsigned short USHORT; int main() { USHORT myAge = 39, yourAge = 39; //kezdőértékek beállítása cout << "I am:\t\t" << myAge << "\tyears old." << endl; cout << "You are:\t" << yourAge << "\tyears old." << endl; myAge++; //postfix növelés ++yourAge; //prefix növelés cout << "One year passes..." << endl; cout << "I am:\t\t" << myAge << "\tyears old." << endl; cout << "You are:\t" << yourAge << "\tyears old." << endl;
12
cout << "Another year passes..." << endl; cout << "I am:\t\t" << myAge++ << "\tyears old." << endl; //először kiírja és utána nőveli meg cout << "You are:\t" << ++yourAge << "\tyears old." << endl; //először megnőveli és utána írja ki cout << "Let's print it again." << endl; cout << "I am:\t\t" << myAge << "\tyears old." << endl; cout << "You are:\t" << yourAge << "\tyears old." << endl; cout << "\nKilepunk..."; cin.get(); //vár az ENTER megnyomására return 0; }
Precedencia, avagy a műveletek végrehajtási sorrendje #include "stdafx.h" #include using namespace std; typedef unsigned short USHORT; int main() { USHORT x; x = 5 + 3 + 8 * 9 + 6 * 4; //először a szorzások, aztán az összeadások cout << "x erteke: " << x << endl; USHORT y = 5, k = 0; x = 3; cout << "x:" << x << " y:" << y << " k:" << k << endl; k = x + y * 15; //most nem így szeretnénk, hanem úgy hogy x+y összegét szorozza 15-nal cout << "x:" << x << " y:" << y << " k:" << k << endl; k = (x + y) * 15; //zárójelekkel állíthatunk a precedencia sorrenden, így azt kapjuk, amit akartunk cout << "x:" << x << " y:" << y << " k:" << k << endl << endl; //egymásba ágyazott zárójelek használata USHORT a = 3, b = 4; cout << "x:" << x << " y:" << y << " a:" << a << " b:" << b << " k:" << k << endl; k = (((x + y) * 15) + (a + b)) * 3; cout << "x:" << x << " y:" << y << " a:" << a << " b:" << b << " k:" << k << endl; cout << "\nKilepunk..."; cin.get(); //vár az ENTER megnyomására return 0; }
Relációs operátorok és az if … else … elágazás #include "stdafx.h" #include using namespace std; typedef unsigned short USHORT; int main() { USHORT szam1, szam2; cout << "Adjon meg egy szamot: "; cin >> szam1; //így olvashatunk be adatot egy változóba cout << "Adjon meg meg egy szamot: ";
13
cin >> szam2; //beolvasás után sort ugrik cout << endl << "Most hasznalom a relaciokat!" << endl; if (szam1 > szam2) //így adjuk meg a feltételt: szam1 nagyobb mint szam2? cout << "szam1 nagyobb mint szam2!" << endl; //ha igen, akkor ezt írom ki else //különben ha nem igaz cout << "szam1 nem nagyobb mint szam2!" << endl; //akkor meg ezt írom ki if (szam1 < szam2) //szam1 kisebb mint szam2? cout << "szam1 kisebb mint szam2!" << endl; else cout << "szam1 nem kisebb mint szam2!" << endl; if (szam1 == szam2) //szam1 és szam2 egyenlő? cout << "szam1 es szam2 egyenlo!" << endl; else cout << "szam1 es szam2 nem egyenlo!" << endl; if (szam1 != szam2) //szam1 és szam2 nem egyenlő? cout << "szam1 es szam2 nem egyenlo!" << endl; else cout << "szam1 es szam2 egyenlo!" << endl; if (szam1 >= szam2) //szam1 nagyobb vagy egyenlő mint szam2? cout << "szam1 nagyobb vagy egyenlo mint szam2!" << endl; else cout << "szam1 kisebb mint szam2!" << endl; if (szam1 <= szam2) //szam1 kisebb vagy egyenlő mint szam2 cout << "szam1 kisebb vagy egyenlo mint szam2!" << endl; else cout << "szam1 nagyobb mint szam2!" << endl; //mivel nem egyszer kérek be, ezért nem működik a kilépésnél a cin.Get() char kilep; //ezért kell egy változó, amibe beolvasok a kilépés előtt cout << "\nKilepunk..."; cin >> kilep; //vár egy karakter beírására return 0; }
Összetett if szerkezet #include "stdafx.h" #include using namespace std; typedef unsigned short USHORT; int main() { USHORT szam1, szam2; cout << "Adjon meg ket szamot!" << endl << "Egyik: "; cin >> szam1; cout << "Masik: "; cin >> szam2; cout << endl; if (szam1 >= szam2) { if ((szam1 % szam2) == 0) { //ha több utasítást akarunk végrehajtani, akkor szükségünk van a { } zárójelre if (szam1 == szam2) cout << "Egyenlo a ket szam!" << endl; //ha egy utasítást akarunk végrehajtani, akkor elhagyható a { } zárójel
14
else cout << "szam2 osztolya szam1-nek!" << endl; } else cout << "szam1 nagyobb mint szam2!" << endl; //ebben az elágazásban egyenlő nem lehet } else cout << "szam1 kisebb mint szam2!" << endl; USHORT x; cout << endl << "Adjon meg egy szamot 10 es 100 kozott: "; cin >> x; if (x >= 10) { //ha a { } zárójelet kihadjuk, akkor logikai hiba keletkezik if (x > 100) cout << "x nagyobb mint 100" << endl; else cout << "Jo szamot adott meg, ami a " << x << "!\n"; } else cout << "x kisebb mint 10" << endl; char kilep; cout << "\nKilepunk..."; cin >> kilep; //vár egy karakter beírására return 0; }
Logikai operátorok #include "stdafx.h" #include using namespace std; typedef unsigned short USHORT; int main() { USHORT x, y, z; cout << "Adjon meg harom szamot!" << endl << "egyik: "; cin >> x; cout << "masik: "; cin >> y; cout << "harmadik: "; cin >> z; cout << endl; if (x > 5 && y > 5 || z > 5) //ebben a példában először az ÉS(&&), majd a VAGY(||) hajtódik végre cout << "Teljesul a feltetel!" << endl; else cout << "Nem teljesul a feltetel!" << endl; if ((x > 5 && y > 5) || z > 5) //ez megegyezik az előzővel, de a zárójelezés érthetőbbé teszi cout << "Eloszor ES, majd VAGY kapcsolat!" << endl; if (x > 5 && (y > 5 || z > 5)) //most másképp van a műveleti sorrend cout << "Eloszor VAGY, majd ES kapcsolat!" << endl; if (x) //ha x igaz (nem nulla) //if ( x != 0) //ez megegyezik az előzővel, és ajánlott ezt használni cout << "x<>0" << endl; if (!y) //ha y hamis (nulla) //if (y == 0) //ez megegyezik az előzővel, és ajánlott ezt használni
15
cout << "y=0" << endl; char kilep; cout << "\nKilepunk..."; cin >> kilep; //vár egy karakter beírására return 0; }
Függvények deklarálása, definiálása és használata #include "stdafx.h" #include using namespace std; typedef unsigned short USHORT; typedef unsigned long ULONG; //azért célszerű a függvény deklarálása (prototípus), mert maga a függvény, akkor a main() után is előfordulhat //ez a prototípus csak akkor kell, ha a függvényt a definiciója előtt hívom meg, prototípus használata ajánlott USHORT teruletsz(USHORT flength, USHORT fwidth); //prototípus deklarálása //itt nem muszáj megadni nevet, de ha adok a típusokhoz nevet is, akkor érthetőbb lesz a függvény működése, //de a függvény neve és a bemenő és kimenő típusok megadása kötelező int main() { USHORT length, width; ULONG terulet; cout << "Adja meg a szelesseget es a hosszusagot!" << endl << "szelesseg: "; cin >> width; cout << "hosszusag: "; cin >> length; terulet = teruletsz(length, width); //függvényhívás //itt nevesített értékeket adok át, de "sima" számot is meglehet adni cout << "A folded " << terulet << " m2 teruletu!" << endl; char kilep; cout << "\nKilepunk..."; cin >> kilep; //vár egy karakter beírására return 0; } USHORT teruletsz(USHORT l, USHORT w) //függvény definició //itt a változó neve eltérhet a prototípusétól, de azonos is lehet { return (l * w); //a visszatérési érték a hosszuság és a szélesség szorzata //visszatérési értéknél kifejezések esetén ajánlott zárójel használata }
Helyi és globális változók #include "stdafx.h" #include using namespace std; float Convert(float TempFer);
16
int main() { float TempFer; //ezek helyi változók, amit csak float TempCel; //a main() függvényben tudok használni cout << "Kerem adja meg a homersekletet Fahrenheitben: "; cin >> TempFer; TempCel = Convert(TempFer); //átadom a TempFer-t a függvénynek és amit visszaad, azt hozzárendelem a TempCel-hez cout << endl << "A megadott homerseklet Celsiusban: " << TempCel << endl; char kilep; cout << "\nKilepunk..."; cin >> kilep; //vár egy karakter beírására return 0; } float Convert(float TempFer) //átvett érték egy helyi változóban { float TempCel; //helyi változó deklarálása TempCel = ((TempFer - 32) * 5) / 9; return TempCel; } //a helyi változók nem a függvényen belül érvényesek, hanem az adott blokkban { } //globális változó az összes függvényen kívül deklarált változó, //ezeket célszerű elkerülni, a helyi változókkal sokkal átláthatóbb a programunk
Helyi változók és az argumentumátadás #include "stdafx.h" #include using namespace std; typedef unsigned short USHORT; void swap(USHORT x, USHORT y); //ez egy eljárás USHORT MyFunction(USHORT egesz, bool logikai); //ez a második példához a függvény int main() { USHORT x = 5, y = 10; cout << "Main. Csere elott, x:" << x << " y:" << y << endl; swap(x, y); //meghívom az eljárást cout << "Main. Csere utan, x:" << x << " y:" << y << endl << endl; //második példa USHORT z = 0; x = 32; y = 5; cout << "z:" << z << endl; z = MyFunction(x, y); //két változót adunk át cout << "z:" << z << endl; z = MyFunction(32, true); //két állandót adunk át cout << "z:" << z << endl; z = MyFunction(23 + 9, 100 > 5); //32-t és igazat adunk át cout << "z:" << z << endl; //amint látjuk, mindhárom argumentum átadással ugyanazt kaptuk eredményül, //mivel maga a függvény is ugyanazokkal az argumentumokkal dolgozót char kilep; cout << "\nKilepunk...";
17
cin >> kilep; //vár egy karakter beírására return 0; } void swap(USHORT x, USHORT y) { USHORT csere; cout << "Csere. Csere elott, x:" << x << " y:" << y << endl; csere = x; x = y; y = csere; cout << "Csere. Csere utan, x:" << x << " y:" << y << endl; } USHORT MyFunction(USHORT egesz, bool logikai) { if (logikai == true) //ha igaz, akkor hozzáadok 5-öt egesz += 5; else //ha nem, akkor kivonunk 5-öt egesz -= 5; return egesz; }
Függvény a függvényben #include "stdafx.h"
#include using namespace std; typedef unsigned short USHORT; //USHORT MyFunction(USHORT egesz, bool logikai); //ez a 3 az első példához kell, //USHORT MyIntFunction(USHORT x, USHORT y); //de most csak megjegyzésben lesz //bool MyBoolFunction(USHORT x, USHORT y); USHORT doubler(USHORT x); //ez a 4 függvény USHORT tripler(USHORT x); //a második példához kell USHORT square(USHORT x); USHORT cube(USHORT x); int main() { USHORT eredmeny = 0; //függvényhívás a függvényhívásban, mint argumentum //eredmeny = MyFunction(MyIntFunction(3, 5), MyBoolFunction(2, 4)); USHORT ertek = 2; cout << "Az eredmeny erteke: " << eredmeny << endl; eredmeny = doubler(tripler(square(cube(ertek)))); cout << "Az eredmeny erteke: " << eredmeny << endl; //az előző megoldás is jó, de a következő megoldás jobban érthető és hibakeresésnél is hatékonyabb USHORT cubed = cube(ertek); //cubed=8 USHORT squared = square(cubed); //squared=64 USHORT tripled = tripler(squared); //tripled=192 /*USHORT*/ eredmeny = doubler(tripled); //eredmeny=384 cout << "Az eredmeny erteke: " << eredmeny << endl; char kilep; cout << "\nKilepunk..."; cin >> kilep; //vár egy karakter beírására
18
return 0; } USHORT doubler(USHORT x) { return (x *= 2); } USHORT tripler(USHORT x) { return (x *= 3); } USHORT square(USHORT x) { return (x * x); } USHORT cube(USHORT x) { return (x * x * x); }
Értékek visszaadása függvényből #include "stdafx.h" #include using namespace std; typedef unsigned short USHORT; USHORT Duplaz(USHORT x); int main() { USHORT result = 0, input; cout << "Adj meg egy szamot 0 es 10000 kozott: "; cin >> input; cout << endl << "Duplazas elott..." << endl; cout << "bemenet:" << input << " visszatero:" << result << endl; result = Duplaz(input); cout << endl << "Duplazas utan..." << endl; cout << "bemenet:" << input << " visszatero:" << result << endl; char kilep; cout << "\nKilepunk..."; cin >> kilep; //vár egy karakter beírására return 0; } USHORT Duplaz(USHORT x) { if (x <= 10000) return (x * 2); //nem kötelező zárójel, de ajánlott else //ez most olyan, mint egy hibakód, egyébként mivel nincs -1, //ezért a legnagyobb értéket rendeli hozzá (túlcsordulás) return -1; //a visszatérési érték lehet konkrét érték (állandó) //return (x > 5); //lehet egy kifejezés, aminek lesz egy értéke, ilyenkor ezt az értéket fogja visszaadni //return (x * 2); //return (MyFunction()); //lehet egy függvény által kapott érték cout << "Ezt mar nem irja ki!" << endl; //a Visual Studio nem figyelmeztet erre (fölösleges utasítás)
19
//egy függvényben több return is elhelyezhető, de ha az egyikhez elér, akkor kilép a függvényből }
Függvények alapértelmezett paraméterei #include "stdafx.h" #include using namespace std; typedef unsigned short USHORT; typedef unsigned long ULONG; ULONG Tterfogat(USHORT length, USHORT width = 25, USHORT height = 1); //nem kötelező nevet adni, lehet így is: USHORT = 25 //ha a paraméterlistában egy elemnek nincs alapértelmezett értéke, //akkor nem lehet előtte olyan paraméter, aminek van int main() { USHORT length = 100; USHORT width = 50; USHORT height = 2; ULONG terfogat; terfogat = Tterfogat(length, width, height); //ez egy normális függvényhívás cout << "Az elso terfogat szamitas eredmenye: " << terfogat << endl; terfogat = Tterfogat(length, width); //itt nem adom meg a height-et, így a függvény az alapértelmezett értéket fogja használni cout << "A masodik terfogat szamitas eredmenye: " << terfogat << endl; terfogat = Tterfogat(length); //azt a paramétert, aminek nincs alapértelmezett értéke, kötelező megadni cout << "A harmadik terfogat szamitas eredmenye: " << terfogat << endl; //olyat nem lehet, hogy a length és height paramétereket adom át, //mert a fordító a sorrend alapján a height helyett a width-re fogja értelmezni char kilep; cout << "\nKilepunk..."; cin >> kilep; //vár egy karakter beírására return 0; } ULONG Tterfogat(USHORT length, USHORT width, USHORT height) //a definició nem változik { return (length * width * height); //a téglatest térfogatának számítása }
Függvények túlterhelése #include "stdafx.h" #include using namespace std; /* typedef unsigned short USHORT; typedef unsigned long ULONG; //ugyanolyan névvel több függvény is létrehozható, ezt nevezzük túlcsordulásnak USHORT myFunction(USHORT, USHORT); //az első függvény USHORT myFunction(ULONG, ULONG); //a második függvény, ha a paraméterek típusai között eltérés van
20
USHORT myFunction(USHORT); //a harmadik függvény, ha a paraméterek száma között eltérés van //ha egy értéket akarunk duplázni, akkor felkell készülni a törtekre is, ezzel ez is lehetséges USHORT Duplaz(USHORT); ULONG Duplaz(ULONG); float Duplaz(float); double Duplaz(double); //meghíváskor Duplaz(x) --- az x lehet egész is, tört is //a következő példában alapértelmezett paramétert használok, így a fordító nem tudja eldönteni, //hogy a Area(input) hívással melyiket hívom meg, ezért ez a túlterhelés nem működik int Area(int width, int length = 1); int Area(int size); */ int main() { cout << "Ez a fuggveny tulterheles bemutatasa, ami a megjegyzesben talalhato!" << endl; cout << "\nKilepunk..."; cin.get(); //vár egy karakter beírására return 0; }
Inline függvények #include "stdafx.h" #include using namespace std; typedef unsigned long ULONG; inline ULONG Duplaz(ULONG); //így használjuk az inline-t //az inline-t használhatjuk pár soros függvényekhez, de hosszabbhoz nem ajánlott //ha használjuk az inline-t, akkor a fordító nem hoz létre függvényt, //hanem a megadott kódot bemásolja minden olyan helyre, ahol a látszólagos függvényt meghívjuk int main() { ULONG x; cout << "Adjon meg egy szamot: "; cin >> x; cout << endl; x = Duplaz(x); //az inline hatására itt megjelenő gépikód: x = 2 * x; cout << "x: " << x << endl; x = Duplaz(x); cout << "x: " << x << endl; x = Duplaz(x); cout << "x: " << x << endl; char kilep; cout << "\nKilepunk..."; cin >> kilep; //vár egy karakter beírására return 0; } ULONG Duplaz(ULONG x) { return (2 * x); }
21
Gyakorlás (Celsius és Fahrenheit közötti átváltás) #include "stdafx.h" #include using namespace std; char Beker(); //nem lesz bemenő paramétere float Convert(float input, char mirol); int main() { char mirol; mirol = Beker(); //Celsiusról vagy Fahrenheitről váltók át if (mirol != '-') { float TempFer; float TempCel; if (mirol == 'c') { cin >> TempCel; TempFer = Convert(TempCel, mirol); cout << endl << "A megadott homerseklet Fahrenheitben: " << TempFer << endl; } else { cin >> TempFer; TempCel = Convert(TempFer, mirol); cout << endl << "A megadott homerseklet Celsiusban: " << TempCel << endl; } } char kilep; cout << "\nKilepunk..."; cin >> kilep; //vár egy karakter beírására return 0; } char Beker() { char mirol; cout << "Kerem adja meg milyen skala szerinti erteket ad meg: "; cin >> mirol; if (mirol == 'c') //itt egyes aposztrófot használók cout << "Kerem adja meg az erteket Celsiusban: "; else { if (mirol == 'f') cout << "Kerem adja meg az erteket Fahrenheitben: "; else { cout << "ERROR. Nem jol adta meg a skalat!" << endl; mirol = '-'; } } return mirol; }
22
float Convert(float input, char mirol) { float output; if (mirol == 'f') output = ((input - 32) * 5) / 9; else output = ((input * 9) / 5) + 32; return output; }
While ciklus #include "stdafx.h" #include using namespace std; typedef unsigned short USHORT; int main() { USHORT szamlalo = 0; //feltételben lévő változó deklarálása while (szamlalo < 5) //ellenőrzés: igaz-e még a feltétel //a program a ciklusmagot addig ismétli, amíg a kezdeti feltétel igaz marad { szamlalo++; //a ciklus magja cout << "Szamlalo: " << szamlalo << endl; } cout << "Kesz. A szamlalo erteke: " << szamlalo << endl; char kilep; cout << "\nKilepunk..."; cin >> kilep; //vár egy karakter beírására return 0; }
Bonyolultabb while ciklus #include "stdafx.h" #include using namespace std; int main() { unsigned short kicsi; unsigned long nagy; const unsigned short MAX = 65535; cout << "Irjon be egy kisebb szamot: "; cin >> kicsi; cout << "Irjon be egy nagyobb szamot: "; cin >> nagy; //nem ellenőrizzük hogy jól adja-e meg az értéket
23
cout << "kisebb: " << kicsi << "..."; //minden iterációs lépésben három feltételt vizsgál while ((kicsi < nagy) && (nagy > 0) && (kicsi < MAX)) //ez egy összetett feltétel { if (kicsi % 5000 == 0) //5000 soronként kiír egy pöttyöt cout << "."; kicsi++; //kicsit nővelem 1-el nagy -= 2; //nagyot csökkentem 2-vel } cout << endl << "Kisebb:" << kicsi << " Nagyobb:" << nagy << endl; char kilep; cout << "\nKilepunk..."; cin >> kilep; //vár egy karakter beírására return 0; }
A continue és a break #include "stdafx.h" #include using namespace std; int main() { unsigned short small; unsigned long large; unsigned long skip; unsigned long target; const unsigned short MAXSMALL = 65535; cout << "Irjon be egy kisebb szamot: "; cin >> small; cout << "Irjon be egy nagyobb szamot: "; cin >> large; cout << "Adjon meg egy szorzoszamot: "; cin >> skip; cout << "Adja meg a tippelt celerteket: "; cin >> target; cout << endl; //a ciklus 3 feltételének megadása while ((small < large) && (large > 0) && (small < MAXSMALL)) { small++; if (small % skip == 0) //kimaradjon a csökkentés? { cout << "kimarad: " << small << endl; continue; //a folyamat a ciklus elejére ugrik, nem fut végig a ciklusmagon } if (large == target) //pontosan egyezik a célértékkel? { cout << "Célba értünk!"; break; //azzonnal elhagyja a ciklust és a ciklus után folytatja a programot } large -= 2; } //a while ciklus vége cout << endl << "Kisebb:" << small << " Nagyobb:" << large << endl;
24
char kilep; cout << "\nKilepunk..."; cin >> kilep; //vár egy karakter beírására return 0; }
Végtelen ciklus a while segítségével #include "stdafx.h" #include using namespace std; int main() { unsigned short szamlalo = 0; //ebben a példában muszáj neki kezdőértéket adni while (1) //ez is egy feltétel, ami soha nem lesz hamis { szamlalo++; if (szamlalo > 10) //ez a megoldás nem szép break; //alkalmatlan eszközzel oldunk meg egy feladatot } cout << "Szamlalo: " << szamlalo << endl; char kilep; cout << "\nKilepunk..."; cin >> kilep; //vár egy karakter beírására return 0; }
A do…while ciklus #include "stdafx.h" #include using namespace std; int main() { signed short szamlalo; //előjeles számlálót használunk cout << "Hany hello legyen? "; cin >> szamlalo; //ez az előltesztelő ciklus, lehet hogy egyszer sen hajtódik végre while (szamlalo > 0) { cout << "Hello! " << endl; szamlalo--; } cout << "A szamlalo allasa: " << szamlalo << endl; cout << endl << "Most hany hello legyen? "; cin >> szamlalo; //most jön a hátultesztelő ciklus, ez minimum egyszer végrehajtódik do { cout << "Hello" << endl; szamlalo--; } while (szamlalo > 0); //így adom meg a feltételt, ha igaz akkor ismétel
25
cout << "A szamlalo allasa: " << szamlalo << endl; //a while és a do ... while ciklus közti különbség a feltételvizsgálat helye
char kilep; cout << "\nKilepunk..."; cin >> kilep; //vár egy karakter beírására return 0; }
A for ciklus #include "stdafx.h" #include using namespace std; int main() { unsigned short szamlalo; for (szamlalo = 0; szamlalo < 5; szamlalo++) cout << "Porgok! "; //a for ciklus három részből áll //for (változó inicializálása;feltétel vizsgálata; változó léptetése) cout << endl << "A szamlalo: " << szamlalo << endl; char kilep; cout << "\nKilepunk..."; cin >> kilep; //vár egy karakter beírására return 0; }
Halmozott inicializáció és léptetés a for ciklusban #include "stdafx.h" #include using namespace std; int main() { //itt egy deklarálás történik, helyesebben 2 for (unsigned short i = 0, j = 0; i < 3; i++, j++) cout << "i:" << i << " j:" << j << endl; char kilep; cout << "\nKilepunk..."; cin >> kilep; //vár egy karakter beírására return 0; }
26
Üres utasítások a for ciklusfejben //most egy olyan ciklust csinálok a for ciklusból, mint a while ciklus #include "stdafx.h" #include using namespace std; int main() { unsigned short szamlalo = 0; for (; szamlalo < 5;) //= while (szamlalo < 5) { szamlalo++; cout << "Porgok! "; } cout << endl << "A szamlalo: " << szamlalo << endl; char kilep; cout << "\nKilepunk..."; cin >> kilep; //vár egy karakter beírására return 0; }
Üres for ciklusfej #include "stdafx.h" #include using namespace std; int main() { unsigned short szamlalo = 0; //deklarálás unsigned short max; cout << "Hany hello legyen? "; cin >> max; for ( ; ; ) //ez látszólag egy végtelen ciklus { if (szamlalo < max) { cout << "Hello!" << endl; szamlalo++; } else break; //kitörünk a ciklusból } char kilep; cout << "\nKilepunk..."; cin >> kilep; //vár egy karakter beírására return 0; }
27
Üres for ciklusmag #include "stdafx.h" #include using namespace std; int main() { for (unsigned short i = 0; i < 5; cout << "i: " << i++ << endl) ; //az előbbi egy példa az üres ciklusmagra cout << endl; //a következő sokkal szebb és jobb megoldás for (unsigned short j = 0; j < 5; j++) cout << "j: " << j << endl; char kilep; cout << "\nKilepunk..."; cin >> kilep; //vár egy karakter beírására return 0; }
Egymásba ágyazott ciklusok #include "stdafx.h" #include using namespace std; int main() { unsigned short sor, oszlop; char jel; cout << "Sorok szama: "; cin >> sor; cout << "Oszlopok szama: "; cin >> oszlop; cout << "Milyen karakter legyen? "; cin >> jel; cout << endl; //így ágyazunk egymásba két for ciklust, ezzel most egy mátrixot járunk be for (unsigned short i = 0; i < sor; i++) { for (unsigned short j = 0; j < oszlop; j++) cout << jel; cout << endl; } char kilep; cout << "\nKilepunk..."; cin >> kilep; //vár egy karakter beírására return 0; }
28
A switch utasítás #include "stdafx.h" #include using namespace std; int main() { unsigned short szam; cout << "Adjon meg egy szamot 1 es 5 kozott: "; cin >> szam; switch (szam) //ez egy többirányű elágazás { case 0: cout << "Sajnos ez tul kicsi!" << endl; break; //ez arra kell hogy kilépjen a switchből, különben a következő utasításra ugrik egyből case 5: cout << "Remek dontes!" << endl; //itt nincs break, így egyből a következő utasításra lép vizsgálat nélkül case 4: //nem kötelező sorrend szerint megadni az értékeket cout << "Jo valasztas!" << endl; //átcsorgunk case 3: cout << "Kituno!" << endl; //átcsorgunk case 2: cout << "Mesteri!" << endl; //átcsorgunk case 1: cout << "Hihetetlen!" << endl; break; default: //mindig érdemes default ágat használni cout << "Tul nagy!" << endl; break; } char kilep; cout << "\nKilepunk..."; cin >> kilep; //vár egy karakter beírására return 0; }
Valós típusú ciklusváltozó használata #include "stdafx.h" #include using namespace std; int main() { float szamlalo; for (szamlalo = 0; szamlalo < 2; szamlalo += 0.1) cout << "Porgok! Szamlalo: " << szamlalo << endl; char kilep; cout << "\nKilepunk..."; cin >> kilep; //vár egy karakter beírására return 0; }
29
Egymásba ágyazott ciklusok II. #include "stdafx.h" #include using namespace std; int main() { unsigned short sor = 3, oszlop = 7; char jel = 'x'; unsigned short i, j; //így ágyazunk egymásba két while ciklust i = 0; while (i < sor) { j = 0; while (j < oszlop) { cout << jel; j++; } cout << endl; i++; } cout << endl; //így ágyazunk egymásba egy for és egy while ciklust jel = '#'; for (i = 0; i < sor; i++) { j = 0; while (j < oszlop) { cout << jel; j++; } cout << endl; } cout << endl; //így ágyazunk egymásba egy while és egy for ciklust jel = 'o'; i = 0; while (i < sor) { for (j = 0; j < oszlop; j++) cout << jel; cout << endl; i++; } char kilep; cout << "\nKilepunk..."; cin >> kilep; //vár egy karakter beírására return 0; }
30
Ciklus a switch ágában #include "stdafx.h" #include using namespace std; int main() { unsigned short szam; cout << "Adjon meg egy szamot 1 es 3 kozott: "; cin >> szam; switch (szam) { case 0: cout << "Sajnos ez tul kicsi!" << endl; break; case 1: cout << "Jo valasztas!" << endl; break; case 2: cout << "Kituno!" << endl; break; case 3: for (unsigned short i = 0; i < szam; i++) cout << "Hihetetlen!" << endl; break; default: cout << "Tul nagy!" << endl; break; } char kilep; cout << "\nKilepunk..."; cin >> kilep; //vár egy karakter beírására return 0; }
Kilépés csak gombbal #include "stdafx.h" #include using namespace std; int main() { cout << "Hello! Most lepj ki!" << endl; cout << endl; char kilep; do { cout << "Kilepeshez nyomjon gombot! "; cin >> kilep; } while (kilep != 'q'); //kilépés csak q (quit) gombbal return 0; }
31
Új osztály létrehozása és használata //változó típusából 3 dolog derül ki: //a memóriaigénye, //milyen jellegű információt tárolhatunk benne, //milyen műveleteket végezhetünk rajta. //az osztály egy új típus definíciója #include "stdafx.h" #include using namespace std; typedef unsigned short USHORT; class Cat //az osztály deklaráció kezdete { public: //ez azért kell, hogy ne csak osztályon belül tudjuk elérni a változókat és függvényeket USHORT GetAge(); //adattagelérési függvény void SetAge(USHORT age); //adattagelérési függvény void Meow(); //általános célú függvény [nyávogás] USHORT Weight; //publikus változó [súly] char Name[255]; //publikus változó [név] private: //ezek privát változók és függvények USHORT itsAge; //its -- segít megkülönböztetni azoktól a változóktól, amelyek nem tagváltozók }; //GetAge, publikus adattagelérési függvény, visszaadja az itsAge tag értékét USHORT Cat::GetAge() { return itsAge; //ez azért kell mert a mainből nem tudjuk elérni, így bentről kell } //SetAge, publikus adattagelérési függvény, amellyel az itsAge tagot módosíthatjuk void Cat::SetAge(USHORT age) { //beállítjuk az itsAge változót, melyet az age változóból kapunk itsAge = age; } //Meow, ez egy egyszerű kiíratás void Cat::Meow() { cout << "Miau." << endl; } //létrehozza a macska egy példányát, beállítja a nevét, a súlyát és az életkorát, //nyávog egyet, megadja az életkorát és újra nyávog int main() { Cat Frisky; //példányosítok egy macskát //így tudom elérni az osztály publikus változóit cout << "Adja meg a macska nevet: "; cin >> Frisky.Name; //bekérem a macska nevét (pl. Kitty) cout << "Adja meg a macska sulyat grammban: "; cin >> Frisky.Weight; //bekérem a macska súlyát (pl. 4,56 kg) USHORT EletKor; //definiálunk egy előjel nélküli változót cout << "Adja meg a macska eletkorat: "; cin >> EletKor; cout << endl;
32
Frisky.SetAge(EletKor); Frisky.Meow(); cout << Frisky.Name << " egy macska, aki " << Frisky.GetAge() << " eves, "; cout << Frisky.Weight << " gramm tomegu." << endl; Frisky.Meow(); cout << endl; char kilep; do { cout << "Kilepeshez nyomjon gombot! "; cin >> kilep; } while (kilep != 'q'); return 0; }
Konstruktorok és destruktorok, avagy az objektumok létrehozása és törlése #include "stdafx.h" #include using namespace std; //using std::cout; -- ha csak a cout-ot használnánk akkor így kéne megadni typedef unsigned short USHORT; class Cat { public: Cat(USHORT initialAge); //konstruktor ~Cat(); //destruktor USHORT GetAge(); void SetAge(USHORT age); void Meow(); private: USHORT itsAge; }; Cat::Cat(USHORT initialAge) //a Cat konstruktora { itsAge = initialAge; } Cat::~Cat() { //ez a destruktor, ami most nem csinál semmit } USHORT Cat::GetAge() { return itsAge; } void Cat::SetAge(USHORT age) { itsAge = age; }
33
void Cat::Meow() { cout << "Miau." << endl; } int main() { Cat Frisky(5); //példányosítok egy macskát, és átadok egy értéket a konstruktornak Frisky.Meow(); cout << "Frisky egy macska, aki " << Frisky.GetAge() << " eves." << endl; Frisky.Meow(); Frisky.SetAge(7); cout << "Most Frisky " << Frisky.GetAge() << " eves." << endl; Frisky.Meow(); cout << endl; char kilep; do { cout << "Kilepeshez nyomjon gombot! "; cin >> kilep; } while (kilep != 'q'); return 0; }
Több példány használata a Cat osztályból #include "stdafx.h" #include using namespace std; typedef unsigned short USHORT; class Cat { public: USHORT GetAge(); void SetAge(USHORT age); void Meow(); private: USHORT itsAge; }; USHORT Cat::GetAge() { return itsAge; } void Cat::SetAge(USHORT age) { itsAge = age; } void Cat::Meow() { cout << "Miau." << endl; }
34
int main() { Cat Frisky; //példányosítok egy macskát USHORT EletKor; cout << "Adja meg Frisky eletkorat: "; cin >> EletKor; Frisky.SetAge(EletKor); Frisky.Meow(); cout << "Frisky egy macska, aki " << Frisky.GetAge() << " eves." << endl; Frisky.Meow(); cout << endl; Cat Spot; //példányosítok egy másik macskát is cout << "Adja meg Spot eletkorat: "; cin >> EletKor; Spot.SetAge(EletKor); //itt nem Frisky életkorát változtatjuk meg, hanem Spot életkorát Spot.Meow(); cout << "Spot egy masik macska, aki " << Spot.GetAge() << " eves." << endl; Spot.Meow(); //Frisky.itsAge++; -- nincs hozzáférési engedélyünk, mert privát változó cout << endl; Frisky.Meow(); cout << "Frisky meg mindig " << Frisky.GetAge() << " eves." << endl; Frisky.Meow(); cout << endl; char kilep; do { cout << "Kilepeshez nyomjon gombot! "; cin >> kilep; } while (kilep != 'q'); return 0; }
Fejlécállományok használata //ez a cat.hpp fájl #include "stdafx.h" #include using namespace std; typedef unsigned short USHORT; class Cat { public: Cat(USHORT initialAge); ~Cat(); USHORT GetAge() //helyben kifejtett megvalósítás { return itsAge; //inline } void SetAge(USHORT age) { itsAge = age; }
35
void Meow() { cout << "Miau." << endl; } private: USHORT itsAge; }; //"cat.cpp" -- ez az osztálymetódus megvalósításának fájlja #include "stdafx.h" //ez itt is kötelező a Visual Studionak #include "cat.hpp" //az osztály deklarációjának fájlja //#include //ez benne van a cat.hpp-ben //using namespace std; //ezek is benne vannak a cat.hpp-ben //typedef unsigned short USHORT; Cat::Cat(USHORT initialAge) { itsAge = initialAge; } Cat::~Cat() { //itt most sincs semmi utasítás } int main() { Cat Frisky(5); Frisky.Meow(); cout << "Frisky egy " << Frisky.GetAge() << " eves macska." << endl; Frisky.Meow(); cout << endl; USHORT EletKor; cout << "Adja meg Frisky eletkorat: "; cin >> EletKor; Frisky.SetAge(EletKor); Frisky.Meow(); cout << "Frisky most mar " << Frisky.GetAge() << " eves." << endl; Frisky.Meow(); cout << endl; char kilep; do { cout << "Kilepeshez nyomjon gombot! "; cin >> kilep; } while (kilep != 'q'); return 0; }
36
Fejlécállományok használata II. //ez a point.hpp fájl forráskódja #include "stdafx.h" #include typedef unsigned short USHORT; class Point //Tartalmazza az X,Y koordinátákat { //nincs konstruktor, az alapértelmezés használandó public: void SetX(USHORT x) { itsX = x; } //kevesebb sor érdekében így deklarálok void SetY(USHORT y) { itsY = y; } //ha nem változtatunk az osztály változóinak értékén, akkor ajánlott konstansként deklarálni a függvényeket USHORT GetX() const { return itsX; } USHORT GetY() const { return itsY; } private: USHORT itsX; USHORT itsY; };
//ez a rect.hpp fájl forráskódja #include "stdafx.h" #include "point.hpp" //beemeljük a point osztályt class Rectangle { public: Rectangle(USHORT top, USHORT left, USHORT bottom, USHORT right); ~Rectangle() { /*üres*/ } USHORT GetTop() const { return itsTop; } USHORT GetLeft() const { return itsLeft; } USHORT GetBottom() const { return itsBottom; } USHORT GetRight() const { return itsRight; } Point GetUpperLeft() const { return itsUpperLeft; } Point GetLowerLeft() const { return itsLowerLeft; } Point GetUpperRight() const { return itsUpperRight; } Point GetLowerRight() const { return itsLowerRight; } void SetUpperLeft(Point Location); void SetLowerLeft(Point Location); void SetUpperRight(Point Location); void SetLowerRight(Point Location); void SetTop(USHORT top); void SetLeft(USHORT left); void SetBottom(USHORT bottom); void SetRight(USHORT right); unsigned long GetArea() const; private: Point itsUpperLeft; Point itsUpperRight; Point itsLowerLeft; Point itsLowerRight; USHORT itsTop; USHORT itsLeft; USHORT itsBottom; USHORT itsRight; };
37
//ez a rect.cpp fájl forráskódja #include "stdafx.h" #include "rect.hpp" //beemeljük a rectangle osztályt using namespace std; Rectangle::Rectangle(USHORT top, USHORT left, USHORT bottom, USHORT right) { itsTop = top; itsLeft = left; itsBottom = bottom; itsRight = right; itsUpperLeft.SetX(left); itsUpperLeft.SetY(top); itsUpperRight.SetX(right); itsUpperRight.SetY(top); itsLowerLeft.SetX(left); itsLowerLeft.SetY(bottom); itsLowerRight.SetX(right); itsLowerRight.SetY(bottom); } void Rectangle::SetUpperLeft(Point Location) { itsUpperLeft = Location; itsUpperRight.SetY(Location.GetY()); itsLowerRight.SetX(Location.GetX()); itsTop = Location.GetY(); itsLeft = Location.GetX(); } void Rectangle::SetLowerLeft(Point Location) { itsLowerLeft = Location; itsLowerRight.SetY(Location.GetY()); itsUpperLeft.SetX(Location.GetX()); itsBottom = Location.GetY(); itsLeft = Location.GetX(); } void Rectangle::SetLowerRight(Point Location) { itsLowerRight = Location; itsLowerLeft.SetY(Location.GetY()); itsUpperRight.SetX(Location.GetX()); itsBottom = Location.GetY(); itsRight = Location.GetX(); } void Rectangle::SetUpperRight(Point Location) { itsUpperRight = Location; itsUpperLeft.SetY(Location.GetY()); itsLowerRight.SetX(Location.GetX()); itsTop = Location.GetY(); itsRight = Location.GetX(); }
38
void Rectangle::SetTop(USHORT top) { itsTop = top; itsUpperLeft.SetY(top); itsUpperRight.SetY(top); } void Rectangle::SetLeft(USHORT left) { itsLeft = left; itsUpperLeft.SetX(left); itsLowerLeft.SetX(left); } void Rectangle::SetBottom(USHORT bottom) { itsBottom = bottom; itsLowerLeft.SetY(bottom); itsLowerRight.SetY(bottom); } void Rectangle::SetRight(USHORT right) { itsRight = right; itsUpperRight.SetX(right); itsLowerRight.SetX(right); } unsigned long Rectangle::GetArea() const { USHORT Width = itsRight - itsLeft; USHORT Height = itsTop - itsBottom; return (Width * Height); } int main() { //a helyi Rectangle változó inicializálása Rectangle MyRectangle(100, 20, 50, 80); //top, left, bottom, right //kiszámoljuk a téglalap területét a sarkok koordinátái alapján unsigned long Area = MyRectangle.GetArea(); cout << "Terulet: " << Area << endl; cout << "Bal felso pont X koordinataja: " << MyRectangle.GetUpperLeft().GetX() << endl; cout << "Bal felso pont Y koordinataja: " << MyRectangle.GetUpperLeft().GetY() << endl; cout << "Jobb also pont X koordinataja: " << MyRectangle.GetLowerRight().GetX() << endl; cout << "Jobb also pont Y koordinataja: " << MyRectangle.GetLowerRight().GetY() << endl; cout << endl; char kilep; do { cout << "Kilepeshez nyomjon gombot! "; cin >> kilep; } while (kilep != 'q'); return 0; }
39
Kilépés csak <ENTER> gombbal #include "stdafx.h" #include #include "conio.h" //a _getch() parancshoz int main() { std::cout << "Hello! Most lepj ki!" << std::endl; std::cout << std::endl << "Kilepeshez nyomjon <ENTER> gombot! "; unsigned short kod; do { kod = _getch(); } while (kod != 13); return 0; }
Memóriacím kiírása #include "stdafx.h" #include #include "conio.h" //a _getch() parancshoz using namespace std; int main() { unsigned short shortVar = 5; unsigned long longVar = 65535; signed long sVar = -65535; //így írjuk ki a változó memóriacímét (&) cout << "shortVar:\t" << shortVar << "\tA shortVar memoriacime:\t" << &shortVar << endl; cout << "longVar:\t" << longVar << "\tA longVar memoriacime:\t" << &longVar << endl; cout << "sVar:\t\t" << sVar << "\tA sVar memoriacime:\t" << &sVar << endl; // -- \\-vel \-t írhatunk ki // -- \"-vel "-t írhatunk ki // -- \'-vel '-t írhatunk ki cout << endl << "Kilepeshez nyomjon <ENTER> gombot! "; unsigned short kod; do { kod = _getch(); } while (kod != 13); return 0; }
Mutatók használata #include "stdafx.h" #include #include "conio.h" //a _getch() parancshoz using namespace std;
40
int main() { unsigned short howOld = 50; //változó létrehozása unsigned short *pAge = NULL; //a pAge egy egész típusú változó memóriacímét tárolja //olyan típusú mutatót hozzunk létre, mint a tárolandó változó típusa //mindig adni kell a mutatónak kezdőértéket, a NULL egy kezdőérték, ami nem mutat semmelyik változóra cout << "NULL ertekkel: " << pAge << endl; pAge = &howOld; //a howOld címének hozzárendelése a pAge-hez cout << "howOld memoriacime: " << pAge << endl; unsigned short yourAge; //egy újabb változó bevezetése //tudjuk hogy a pAge mutató a howOld változó címére mutat, ahol 50 található yourAge = *pAge; //így közvetett eléréssel tudom elérni a howOld változó értékét cout << "yourAge tartalma: " << yourAge << endl; cout << endl << "Kilepeshez nyomjon <ENTER> gombot! "; unsigned short kod; do { kod = _getch(); } while (kod != 13); return 0; }
Adatváltoztatás mutatók használatával #include "stdafx.h" #include #include "conio.h" //a _getch() parancshoz using namespace std; int main() { unsigned short myAge; //egy változó unsigned short *pAge = NULL; //egy mutató myAge = 5; pAge = &myAge; //myAge címének hozzárendelése a pAge-hez cout << "myAge: " << myAge << endl; cout << "*pAge: " << *pAge << endl << endl; cout << "*pAge = 7" << endl; *pAge = 7; //a 7 érték hozzárendelése a myAge-hez cout << "*pAge: " << *pAge << endl; cout << "myAge: " << myAge << endl << endl; cout << "myAge = 9" << endl; myAge = 9; cout << "myAge: " << myAge << endl; cout << "*pAge: " << *pAge << endl; cout << endl << "Kilepeshez nyomjon <ENTER> gombot! "; unsigned short kod; do { kod = _getch(); } while (kod != 13); return 0; }
41
A mutatókban tárolt címek vizsgálata #include "stdafx.h" #include #include "conio.h" //a _getch() parancshoz using namespace std; int main() { unsigned short myAge = 5, yourAge = 10; unsigned short *pAge = &myAge; cout << "myAge:\t" << myAge; cout << "\t\tyourAge:\t" << yourAge << endl; cout << "&myAge:\t" << &myAge; cout << "\t&yourAge:\t" << &yourAge << endl; cout << "pAge:\t" << pAge << endl; cout << "*pAge:\t" << *pAge << endl << endl; pAge = &yourAge; cout << "myAge:\t" << myAge; cout << "\t\tyourAge:\t" << yourAge << endl; cout << "&myAge:\t" << &myAge; cout << "\t&yourAge:\t" << &yourAge << endl; cout << "pAge:\t" << pAge << endl; cout << "*pAge:\t" << *pAge << endl << endl; cout << "&pAge:\t" << &pAge << endl; cout << endl << "Kilepeshez nyomjon <ENTER> gombot! "; unsigned short kod; do { kod = _getch(); } while (kod != 13); return 0; }
Memóriafoglalás és mutatók törlése #include "stdafx.h" #include #include "conio.h" //a _getch() parancshoz using namespace std; typedef unsigned short USHORT; int main() { USHORT localVariable = 5; USHORT *pLocal = &localVariable; USHORT *pHeap = new USHORT; //így foglalunk le dinamikus memóriáterületet *pHeap = 7; //értéket tesszünk a dinamikus memóriaterületre cout << "localVariable: " << localVariable << endl; cout << "*pLocal: " << *pLocal << endl;
42
cout << "*pHeap: " << *pHeap << endl; delete pHeap; //memóriaterület felszabadítása pHeap = new USHORT; //a törlés után újra felhasználható a mutató *pHeap = 9; //újra memóriacímet rendelünk hozzá cout << "*pHeap: " << *pHeap << endl; delete pHeap; //újra felszabadítjuk a lefoglalt területet pHeap = NULL; //a mutatót NULL-ra állítom, hogy ne mutasson semmire delete pHeap; //veszélytelen törlés (töröljük a NULL-t) //a pLocal álltal mutatót memóriaterületet nem szabadítottam fel, //de a program kilépése után a memóriában lefoglalt összes terület magától felszabadításra kerül, //de ajánlott a programban felszabadítani őket cout << endl << "Kilepeshez nyomjon <ENTER> gombot! "; USHORT kod; do { kod = _getch(); } while (kod != 13); return 0; }
A memóriaszivárgás elkerülése #include "stdafx.h" #include #include "conio.h" using namespace std; typedef unsigned short USHORT; int main() { USHORT *pPointer = new USHORT; //létrehozunk egy mutatót, amihez egy memóriaterületet rendelünk cout << "*pPointer: " << *pPointer << endl; *pPointer = 72; //a memóriaterületre a 72-t elhelyezzük cout << "*pPointer: " << *pPointer << endl; delete pPointer; //ha nem töröljük akkor memóriaszívárgás lép fel pPointer = NULL; cout << "*pPointer: NULL" << endl; pPointer = new USHORT; //létrehozunk egy másik memóriaterületet és hozzárendeljük a mutatóhoz cout << "*pPointer: " << *pPointer << endl; *pPointer = 84; //a memóriaterületre a 84-et elhelyezzük cout << "*pPointer: " << *pPointer << endl; cout << endl << "Kilepeshez nyomjon <ENTER> gombot! "; USHORT kod; do { kod = _getch(); } while (kod != 13); return 0; }
43
Objektumok létrehozása és törlése a dinamikusan kezelt memóriában #include "stdafx.h" #include #include "conio.h" using namespace std; typedef unsigned short USHORT; class SimpleCat { public: SimpleCat(); ~SimpleCat(); private: USHORT itsAge; }; SimpleCat::SimpleCat() { cout << "Constructor called." << endl; itsAge = 1; } SimpleCat::~SimpleCat() { cout << "Destructor called." << endl; } int main() { cout << "SimpleCat Frisky..." << endl; SimpleCat Frisky; cout << "SimpleCat *pRags = new SimpleCat..." << endl; SimpleCat *pRags = new SimpleCat; cout << "delete pRags..." << endl; delete pRags; pRags = NULL; cout << "Exiting, watch Frisky go..." << endl; cout << endl << "Kilepeshez nyomjon <ENTER> gombot! "; USHORT kod; do { kod = _getch(); } while (kod != 13); return 0; }
44
Adattagok elérése mutatókon keresztül #include "stdafx.h" #include #include "conio.h" using namespace std; typedef unsigned short USHORT; class SimpleCat { public: SimpleCat() { itsAge = 2; } ~SimpleCat() { /*üres*/ } USHORT GetAge() const { return itsAge; } void SetAge(USHORT age) { itsAge = age; } private: USHORT itsAge; }; int main() { SimpleCat *Frisky = new SimpleCat; cout << "Frisky " << Frisky->GetAge() << " eves" << endl; //a -> használatával a mutató által mutatott objektum adataihoz férek hozzá Frisky->SetAge(5); cout << "Frisky " << Frisky->GetAge() << " eves" << endl; delete Frisky; Frisky = NULL; _getch(); //várok egy gombnyomásig return 0; }
Adattagok a dinamikus memóriában #include "stdafx.h" #include #include "conio.h" using namespace std; typedef unsigned short USHORT; class SimpleCat { public: SimpleCat(); ~SimpleCat(); USHORT GetAge() const { return *itsAge; } void SetAge(USHORT age) { *itsAge = age; } USHORT GetWeight() const { return *itsWeight; } void SetWeight(USHORT weight) { *itsWeight = weight; } private: USHORT *itsAge; USHORT *itsWeight; };
45
SimpleCat::SimpleCat() { itsAge = new USHORT(2); itsWeight = new USHORT(5); } SimpleCat::~SimpleCat() { delete itsAge; delete itsWeight; itsAge = NULL; itsWeight = NULL; } int main() { SimpleCat *Frisky = new SimpleCat; cout << "Frisky " << Frisky->GetAge() << " eves" << endl; cout << "Frisky " << Frisky->GetWeight() << " kg" << endl; Frisky->SetAge(5); Frisky->SetWeight(7); cout << "Frisky " << Frisky->GetAge() << " eves" << endl; cout << "Frisky " << Frisky->GetWeight() << " kg" << endl; delete Frisky; Frisky = NULL; _getch(); return 0; }
Magyar karakterek használata a programban #include "stdafx.h" //a Visual Studio-hoz #include //std-hez #include "conio.h" //_getch() parancshoz #include //a magyar karakterekhez using namespace std; //cout és endl parancshoz int main() { setlocale(LC_ALL, ""); //beállítom az operációs rendszer álltal használt karakterkészletet cout << "Ez a program bemutatja a magyar ékezetes karakterek használatát!" << endl; cout << "A magyar ékezetes karakterek: á é í ó ö ő ú ü ű" << endl; cout << "Kilépéshez nyomd le valamelyik billentyűzetet! "; _getch(); //várok egy billentyűzet lenyomást return 0; }
A this mutató #include "stdafx.h" #include #include "conio.h" #include
46
using namespace std; typedef unsigned short USHORT; class Rectangle { public: Rectangle(); ~Rectangle(); //így használom a this mutatót, ami az objektumra mutat, ezt a fordító hozza létre void SetLength(USHORT length) { this -> itsLength = length; } USHORT GetLength() const { return this -> itsLength; } void SetWidth(USHORT width) { itsWidth = width; } USHORT GetWidth() const { return itsWidth; } private: USHORT itsLength; USHORT itsWidth; }; Rectangle::Rectangle() { itsWidth = 5; itsLength = 10; } Rectangle::~Rectangle() { /*üres*/ } int main() { setlocale(LC_ALL, ""); Rectangle theRect; cout << "Téglalapom " << theRect.GetLength() << " láb hosszú." << endl; cout << "Téglalapom " << theRect.GetWidth() << " láb széles." << endl; theRect.SetLength(20); theRect.SetWidth(10); cout << "Téglalapom " << theRect.GetLength() << " láb hosszú." << endl; cout << "Téglalapom " << theRect.GetWidth() << " láb széles." << endl; _getch(); return 0; }
Konstans mutatók és konstans tagfüggvények #include "stdafx.h" #include #include "conio.h" #include using namespace std; typedef unsigned short USHORT; class Rectangle { public: Rectangle() { itsWidth = 5; } ~Rectangle() { /*üres*/ }
47
void SetWidth(USHORT width) { itsWidth = width; } USHORT GetWidth() const { return itsWidth; } private: USHORT itsWidth; }; int main() { setlocale(LC_ALL, ""); Rectangle *pRect = new Rectangle; //mutatóval létrehozott téglalap const Rectangle *pConstRect = new Rectangle; //konstans téglalap, értékét nem tudom változtatni Rectangle * const pConstPtr = new Rectangle; //konstans mutató, címét nem tudom változtatni cout << "pRect szélessége: " << pRect->GetWidth() << " láb" << endl; cout << "pConstRect szélessége: " << pConstRect->GetWidth() << " láb" << endl; cout << "pConstPtr szélessége: " << pConstPtr->GetWidth() << " láb" << endl; pRect->SetWidth(10); // pConstRect -> SetWidth(10); //error pConstPtr->SetWidth(10); cout << "pRect szélessége: " << pRect->GetWidth() << " láb" << endl; cout << "pConstRect szélessége: " << pConstRect->GetWidth() << " láb" << endl; cout << "pConstPtr szélessége: " << pConstPtr->GetWidth() << " láb" << endl; _getch(); return 0; }
Egy dimenziós tömb használata #include "stdafx.h" #include #include "conio.h" using namespace std; void pMagyar() { setlocale(LC_ALL, "hun"); } //karakterkészlet legyen magyar void pVege() { cout << "Kilépés..."; _getch(); } //kilépés valamilyen gombbal void ClrScr() { system("cls"); } //képernyő törlése void pTorol() { cin.clear(); fflush(stdin); } //puffer törlése int main() { pMagyar(); //beállítom a karakterkészletett magyarra unsigned short tomb[5] = { 0, 0, 0, 0, 0 }; //5 elemű tömb deklarálása kezdőértékkel cout << "Adjon meg egy számot a vektor 1. helyére: "; cin >> tomb[1]; //beolvasom a vektor 1. helyére, de ez tulajdonképp a 2., mert 0-tól 4-ig van a vektor pTorol(); //cin tartalmának törlése cout << "Adjon meg egy számot a vektor 2. helyére: "; cin >> tomb[2]; ClrScr(); //képernyő törlése saját függvénnyel tomb[3] = tomb[1] + tomb[2]; cout << "A vektor 0. helyén " << tomb[0] << " áll." << endl; cout << "A vektor 1. helyén " << tomb[1] << " áll." << endl; cout << "A vektor 2. helyén " << tomb[2] << " áll." << endl; cout << "A vektor 3. helyén " << tomb[3] << " áll." << endl;
48
cout << "A vektor 4. helyén " << tomb[4] << " áll." << endl; pVege(); //várok egy gomb lenyomást return 0; }
Egy dimenziós tömb bejárása #include "stdafx.h" #include #include "conio.h" using namespace std; void pMagyar() { setlocale(LC_ALL, "hun"); } void pVege() { cout << endl << "Kilépés..."; _getch(); } int main() { pMagyar(); unsigned short tomb[5] = { 0, 0, 0, 0, 0 }; for (unsigned short i = 0; i < 5; i++) { cout << "Add meg az " << i + 1 << ". számot! "; cin >> tomb[i]; } cout << endl; for (unsigned short i = 0; i < 5; i++) { cout << "A tömb " << i + 1 << ". eleme: " << tomb[i] << endl; } pVege(); return 0; }
Összegzés, eldöntés és kiválasztás tétele #include "stdafx.h" #include #include "conio.h" #include //random szám generáláshoz using namespace std; typedef unsigned short USHORT; void pMagyar() { setlocale(LC_ALL, "hun"); } void pVege() { cout << endl << "Kilépés..."; _getch(); } int main() { pMagyar(); const USHORT N = 20; USHORT tomb[N]; { //tömb feltöltése srand(time(NULL)); //randomozas elindítása (véletlen generálás) for (USHORT i = 0; i < N; i++) tomb[i] = rand() % 100; //random(100), tehát 0..99 }
49
{ //tömb elemeinek kiíratása cout << "A tömb elemei: " << endl; for (USHORT i = 0; i < N; i++) cout << tomb[i] << " "; //kiírom a tömb elemeit, szóközzel vannak elválasztva cout << endl; //lépjen új sorba az összes elem kiírása után } { //az összegzés tétele USHORT osszeg = 0; for (USHORT i = 0; i < N; i++) osszeg = osszeg + tomb[i]; //összeadom a tömb elemeit cout << endl << "A tömb elemeinek összege: " << osszeg << endl; } { //eldöntés tétele //annak eldöntése, hogy van-e a tömbben legalább egy "T" tulajdonsággal rendelkező elem USHORT i = 0; bool van = false; do { if (tomb[i] % 7 == 0) //Van-e 7-tel osztható szám a tömbben? van = true; //van "T" tulajdonságú elem i++; } while ((i != N) && (van == false)); //ha hamis, akkor lép tovább if (van == true) cout << "Van 7-tel osztható elem a tömbben!" << endl; else cout << "Nincs 7-tel osztható elem a tömbben!" << endl; } { //a kiválasztás tétele, biztosan van "T" tulajdonságú elem //a tömb első "T" tulajdonsággal rendelkező elemének a sorszámának meghatározása USHORT i = 0; USHORT sorszam = 0; bool van = false; do { if (tomb[i] % 7 == 0) { van = true; sorszam = i; //ez a sorszámú elem osztható 7-tel } i++; } while (van == false); cout << "A \"T\" tulajdonságú elem a " << sorszam + 1 << ". helyen található" << endl; } //így \” tudok kiírni ”-t pVege(); return 0; }
Összegzés, eldöntés és kiválasztás tétele a dinamikus memóriában #include "stdafx.h" #include #include "conio.h" #include //random szám generáláshoz using namespace std; typedef unsigned short USHORT; const USHORT N = 20; void fMagyar() { setlocale(LC_ALL, "hun"); }
50
void fVege() { cout << endl << "Kilépés..."; _getch(); } class Tomb { public: void Feltolt(); void Kiirat() const; USHORT Osszegzes() const; bool Eldontes() const; USHORT Kivalasztas() const; USHORT KapTomb(USHORT elem) const; private: USHORT tomb[N]; }; int main() { fMagyar(); srand(time(NULL)); //randomozas elindítása (véletlen generálás) Tomb *myTomb = new Tomb; bool tovabb = false; do { myTomb->Feltolt(); tovabb = myTomb->Eldontes(); } while(tovabb == false); myTomb->Kiirat(); cout << endl << "A tömb elemeinek összege: " << myTomb->Osszegzes() << endl; cout << myTomb->Kivalasztas() << ". helyen 7-tel osztható szám található." << endl; USHORT yourTomb[N]; for (USHORT i = 0; i < N; i++) yourTomb[i] = myTomb->KapTomb(i); cout << endl << "Az átvett tömb elemei: " << endl; for (USHORT i = 0; i < N; i++) cout << yourTomb[i] << " "; cout << endl; fVege(); return 0; } void Tomb::Feltolt() //tömb feltöltése { for (USHORT i = 0; i < N; i++) tomb[i] = rand() % 100; //random(100), tehát 0..99 } void Tomb::Kiirat() const //tömb elemeinek kiíratása { cout << "A tömb elemei: " << endl; for (USHORT i = 0; i < N; i++) cout << tomb[i] << " "; //kiírom a tömb elemeit, szóközzel vannak elválasztva cout << endl; //lépjen új sorba az összes elem kiírása után } USHORT Tomb::Osszegzes() const//az összegzés tétele { USHORT osszeg = 0; for (USHORT i = 0; i < N; i++) osszeg = osszeg + tomb[i]; //összeadom a tömb elemeit return osszeg; }
51
bool Tomb::Eldontes() const //eldöntés tétele { //annak eldöntése, hogy van-e a tömbben legalább egy "T" tulajdonsággal rendelkező elem USHORT i = 0; bool van = false; do { if (tomb[i] % 7 == 0) //Van-e 7-tel osztható szám a tömbben? van = true; //van "T" tulajdonságú elem i++; } while ((i != N) && (van == false)); //ha igaz, akkor ismétel return van; } USHORT Tomb::Kivalasztas() const //a kiválasztás tétele, biztosan van "T" tulajdonságú elem { //a tömb első "T" tulajdonsággal rendelkező elemének a sorszámának meghatározása USHORT i = 0; USHORT index = 0; bool van = false; do { if (tomb[i] % 7 == 0) { van = true; index = i; //ez a sorszámú elem osztható 7-tel } i++; } while (van != true); return (index + 1); } USHORT Tomb::KapTomb(USHORT elem) const { USHORT ertek; ertek = tomb[elem]; return ertek; }
Lineáris keresés, megszámlálás, kiválogatás, maximum-kiválasztás és minimum-kiválasztás tétele #include "stdafx.h" #include #include "conio.h" #include using namespace std; typedef unsigned short USHORT; const USHORT N = 10; void fMagyar() { setlocale(LC_ALL, "hun"); } void fVege() { cout << endl << "Kilépés..."; _getch(); } class Tomb { public: void Feltolt(); void Kiirat() const; USHORT LinKereses() const; USHORT Megszamlalas() const; USHORT Maximum() const;
52
USHORT Minimum() const; void Kivalogatas() const; //ezt másképp nem tudtam megoldani még USHORT KapTomb(USHORT elem) const; private: USHORT tomb[N]; }; int main() { fMagyar(); srand(time(NULL)); Tomb *myTomb = new Tomb; myTomb->Feltolt(); myTomb->Kiirat(); cout << endl; USHORT index; index = myTomb->LinKereses(); if (index != N) //ha van "T" tulajdonságú elem cout << "A(z) " << index << ". elem az első 3-mal osztható szám a tömbben." << endl; else cout << "Nincs 3-mal osztható szám a tömbben." << endl; cout << myTomb->Megszamlalas() << "db 3-mal osztható szám van a tömbben." << endl; myTomb->Kivalogatas(); cout << "A tömb legnagyobb eleme: " << myTomb->Maximum() << endl; cout << "A tömb " << myTomb->Minimum() + 1 << ". eleme a legkisebb, aminek az értéke: "; cout << myTomb->KapTomb(myTomb->Minimum()) << endl; fVege(); return 0; } void Tomb::Feltolt() { for (USHORT i = 0; i < N; i++) tomb[i] = rand() % 50; } void Tomb::Kiirat() const { cout << "A tömb elemei: " << endl; for (USHORT i = 0; i < N; i++) cout << tomb[i] << " "; cout << endl; } USHORT Tomb::KapTomb(USHORT elem) const { USHORT ertek; ertek = tomb[elem]; return ertek; } USHORT Tomb::LinKereses() const //a lineáris keresés tétele rendezetlen tömbben { //Eldönti, hogy van-e "T" tulajdonságú elem a tömbben, és kiírja a sorszámát, vagy hogy nincs olyan USHORT i = 0; bool van = false; do { if (tomb[i] % 3 == 0) van = true; i++; } while((van != true) && (i != N)); //ha igaz, akkor ismétel
53
if (van != true) i = N; //0..N-1, így ha N, akkor nincs return i; //itt most tényleg az i. és nem az i+1. elem kell } USHORT Tomb::Megszamlalas() const //a megszámlálás tétele { USHORT db = 0; for (USHORT i = 0; i < N; i++) if (tomb[i] % 3 == 0) db++; return db; } USHORT Tomb::Maximum() const //a maximum-kiválasztás tétele { //a tömb legnagyobb elemét (értékét) keressük USHORT max; max = tomb[0]; for (USHORT i = 0; i < N; i++) if (tomb[i] > max) max = tomb[i]; return max; } USHORT Tomb::Minimum() const //a minimum-kiválasztás tétele { //a tömb legkisebb elemét (indexét) keressük USHORT min = 0; //most az indexet tárolom, nem az értéket for (USHORT i = 1; i < N; i++) if (tomb[i] < tomb[min]) min = i; return min; } void Tomb::Kivalogatas() const //a kiválogatás tétele { //az összes "T" tulajdonságú elem indexét tároljuk az indexek[] vektorban USHORT db = 0; USHORT indexek[N]; //ettől több biztos hogy nem lesz for (USHORT i = 0; i < N; i++) if (tomb[i] % 3 == 0) { indexek[db] = i; //a sorszámot tároljuk db++; } //most helyben valósítjuk meg a kiíratást, mert még nem tudom hogy adjam át a tömböt cout << "A 3-mal osztható elemek: "; for (USHORT i = 0; i < db; i++) cout << tomb[indexek[i]] << " "; cout << endl; }
Metszetképzés és unióképzés tétele #include "stdafx.h" #include #include "conio.h" #include using namespace std; typedef unsigned short USHORT; const USHORT N = 20; const USHORT M = 15;
54
void fMagyar() { setlocale(LC_ALL, "hun"); } void fVege() { cout << endl << "Kilépés..."; _getch(); } void Randomize() { srand(time(NULL)); } //pascal formula alkalmazása USHORT Random(USHORT ertek) { return (rand() % ertek); } //pascal formula alkalmazása class Tomb { public: void Feltolt(); void Kiirat() const; USHORT KapTombA(USHORT elem) const { return A[elem]; } USHORT KapTombB(USHORT elem) const { return B[elem]; } USHORT KapTombMetszet(USHORT elem) const { return metszet[elem]; } USHORT KapTombUnio(USHORT elem) const { return unio[elem]; } void Nullaz(); void KepezMetszet(); void KepezUnio(); private: USHORT A[N]; USHORT B[M]; USHORT metszet[M]; //M a kisebb USHORT unio[N + M]; //lehet hogy nincs azonos elem }; int main() { fMagyar(); Randomize(); Tomb *myTomb = new Tomb; myTomb->Nullaz(); myTomb->Feltolt(); myTomb->Kiirat(); cout << endl; myTomb->KepezMetszet(); myTomb->KepezUnio(); USHORT i = 0; cout << "A két halmaz metszete:" << endl; while (myTomb->KapTombMetszet(i) != 0) { cout << myTomb->KapTombMetszet(i) << " "; i++; } cout << endl; cout << "A kéthalmaz uniója:" << endl; i = 0; while (myTomb->KapTombUnio(i) != 0) { cout << myTomb->KapTombUnio(i) << " "; i++; } cout << endl; delete(myTomb); //törlöm az objektumot myTomb = NULL; //NULL-ra állítom a mutatót fVege(); return 0; } void Tomb::Nullaz() { for (USHORT i = 0; i < M; i++) metszet[i] = 0; for (USHORT i = 0; i < (N + M); i++) unio[i] = 0; }
55
void Tomb::Feltolt() { //így töltöm fel a tömböt, hogy ne legyen azonos elem bool rossz; A[0] = Random(50) + 1; for (USHORT i = 1; i < N; i++) do { rossz = false; A[i] = Random(50) + 1; for (USHORT j = 0; j < (i - 1); j++) if (A[i] == A[j]) rossz = true; } while(rossz == true); B[0] = Random(50) + 1; for (USHORT i = 1; i < M; i++) do { rossz = false; B[i] = Random(50) + 1; for (USHORT j = 0; j < (i - 1); j++) if (B[i] == B[j]) rossz = true; } while (rossz == true); } void Tomb::Kiirat() const { cout << "A[ ]: "; for (USHORT i = 0; i < N; i++) cout << A[i] << " "; cout << endl; cout << "B[ ]: "; for (USHORT i = 0; i < M; i++) cout << B[i] << " "; cout << endl; } void Tomb::KepezMetszet() //a metszetképzés tétele { //Két halmaz metszetébe azok az elemek tartoznak, amelyek mindkettőben szerepelnek USHORT j; USHORT db = 0; for (USHORT i = 0; i < N; i++) //az A[ ] elemei { j = 0; while ((j <= M) && (A[i] != B[j])) j++; //a B[ ] elemei if (j <= M) //ha volt egyező elem { metszet[db] = A[i]; //beletesszük a metszet[ ] vektorba db++; } } //ahol nem 0 van a vektorban, ott akkor közös elem található, ezért kellett a nullázás } void Tomb::KepezUnio() //az unióképzés tétele { //Két halmaz egyesítésében azok az elemek tartoznak, amelyek legalább az egyikben szerepelnek for (USHORT i = 0; i < N; i++) unio[i] = A[i]; //először az A[ ] elemeit beletesszük az unio[ ]-ba USHORT db = N; USHORT j; for (USHORT i = 0; i < M; i++) { j = 0;
56
while ((j < N) && (A[j] != B[i])) j++; if (j >= N) //ha nincs közös elem { unio[db] = B[i]; //akkor belerakjuk az elemet unio[ ]-ba db++; } } }
Minimum kiválasztásos, maximum kiválasztásos, buborék és beszúrásos rendezés #include "stdafx.h" #include #include "conio.h" #include using namespace std; typedef unsigned short USHORT; const USHORT N = 10; void fMagyar() { setlocale(LC_ALL, "hun"); } void fVege() { cout << endl << "Kilépés..."; _getch(); } void Randomize() { srand(time(NULL)); } USHORT Random(USHORT ertek) { return (rand() % ertek); } class Tomb { public: void Feltolt(); void Kiirat() const; void RendezMinimum(); void RendezMaximum(); void RendezBuborek(); void RendezBeszuras(); USHORT KapTomb(USHORT elem) const { return tomb[elem]; } USHORT KapTombRendezve(USHORT elem) const { return rendezve[elem]; } private: USHORT tomb[N]; USHORT rendezve[N]; }; int main() { fMagyar(); Randomize(); Tomb *myTomb = new Tomb; myTomb->Feltolt(); myTomb->Kiirat(); cout << endl; myTomb->RendezMaximum(); cout << "A tömb maximum kiválasztással rendezve: "; for (USHORT i = 0; i < N; i++) cout << myTomb->KapTombRendezve(i) << " "; cout << endl; myTomb->RendezMinimum(); cout << "A tömb minimum kiválasztással rendezve: ";
57
for (USHORT i = 0; i < N; i++) cout << myTomb->KapTombRendezve(i) << " "; cout << endl; myTomb->RendezBuborek(); cout << "A tömb buborékosan rendezve: "; for (USHORT i = 0; i < N; i++) cout << myTomb->KapTombRendezve(i) << " "; cout << endl; myTomb->RendezBeszuras(); cout << "A tömb beszúrással rendezve: "; for (USHORT i = 0; i < N; i++) cout << myTomb->KapTombRendezve(i) << " "; cout << endl; delete(myTomb); myTomb = NULL; fVege(); return 0; } void Tomb::Feltolt() { //úgy töltöm fel a tömböt, hogy ne legyen azonos elem bool rossz; tomb[0] = Random(30) + 1; for (USHORT i = 1; i < N; i++) do { rossz = false; tomb[i] = Random(30) + 1; for (USHORT j = 0; j < (i - 1); j++) if (tomb[i] == tomb[j]) rossz = true; } while(rossz == true); } void Tomb::Kiirat() const { cout << "A tömb elemei: "; for (USHORT i = 0; i < N; i++) cout << tomb[i] << " "; cout << endl; } void Tomb::RendezMinimum() //minimum kiválasztásos rendezés tétele { for (USHORT i = 0; i < N; i++) rendezve[i] = tomb[i]; USHORT min; USHORT csere; for (USHORT i = 0; i < (N - 1); i++) { min = i; for (USHORT j = i + 1; j < N; j++) if (rendezve[j] < rendezve[min]) min = j; if (i != min) { csere = rendezve[i]; rendezve[i] = rendezve[min]; rendezve[min] = csere; } } }
58
void Tomb::RendezMaximum() //maximum kiválasztásos rendezés tétele { for (USHORT i = 0; i < N; i++) rendezve[i] = tomb[i]; USHORT max; USHORT csere; for (USHORT i = 0; i < (N - 1); i++) { max = i; for (USHORT j = i + 1; j < N; j++) if (rendezve[j] > rendezve[max]) max = j; if (i != max) { csere = rendezve[i]; rendezve[i] = rendezve[max]; rendezve[max] = csere; } } } void Tomb::RendezBuborek() //buborékos rendezés tétele //minden szomszédos elempárt megvizsgál, és a nagyobbat helyezi hátrébb, //így a legnagyobb lesz hátul és az egyre kisebbek előrébb //a maradék elemek legnagyobbika úgy halad át a tömbön, mint egy buborék, innen kapta a nevét { for (USHORT i = 0; i < N; i++) rendezve[i] = tomb[i]; USHORT csere; for (USHORT i = 0; i < (N - 1); i++) for (USHORT j = 0; j < (N - 1); j++) if (rendezve[j] > rendezve[j + 1]) { csere = rendezve[j]; rendezve[j] = rendezve[j + 1]; rendezve[j + 1] = csere; } } void Tomb::RendezBeszuras() //beszúrásos rendezés tétele { //a tömb elemeit úgy adom át a másik tömbnek, hogy azt közben rendezem ("2 in 1") rendezve[0] = tomb[0]; USHORT j; USHORT csere; for (USHORT i = 1; i < N; i++) { rendezve[i] = tomb[i]; if (rendezve[i] < rendezve[i - 1]) { csere = rendezve[i]; j = i; do { j--; rendezve[j + 1] = rendezve[j]; } while((rendezve[j - 1] > csere) && (j >= 1)); rendezve[j] = csere; } } }
59
Kétdimenziós tömb (mátrix) használata #include "stdafx.h" #include #include "conio.h" using namespace std; typedef unsigned short USHORT; const USHORT N = 7; const USHORT M = 3; void fMagyar() { setlocale(LC_ALL, "hun"); } void fVege() { cout << endl << "Kilépés..."; _getch(); } int main() { fMagyar(); USHORT tomb[N][M]; //kétdimenziós tömb deklarálása for (USHORT i = 0; i < N; i++) for (USHORT j = 0; j < M; j++) { cout << "Add meg a(z) " << i + 1 << ". nap " << j + 1 << ". mérési adatát: "; cin >> tomb[i][j]; //beolvasom az adatokat } USHORT osszeg = 0; for (USHORT i = 0; i < N; i++) for (USHORT j = 0; j < M; j++) { osszeg += tomb[i][j]; //osszeg = osszeg + tomb[i][j]; } cout << endl << "Az összeg: " << osszeg << endl; fVege(); return 0; }
N dimenziós tömb használata #include "stdafx.h" #include #include "conio.h" using namespace std; typedef unsigned short USHORT; void fMagyar() { setlocale(LC_ALL, "hun"); } void fVege() { cout << endl << "Kilépés..."; _getch(); } int main() { fMagyar(); USHORT tomb[2][2][2][2][2]; //N dimenziós tömb deklarálása for (USHORT i = 0; i < 2; i++) for (USHORT j = 0; j < 2; j++) for (USHORT k = 0; k < 2; k++) for (USHORT l = 0; l < 2; l++) for (USHORT m = 0; m < 2; m++) {
60
cout << "Add meg az adatot! "; cin >> tomb[i][j][k][l][m]; //beolvasom az adatokat } cout << endl; USHORT osszeg = 0; for (USHORT i = 0; i < 2; i++) for (USHORT j = 0; j < 2; j++) for (USHORT k = 0; k < 2; k++) for (USHORT l = 0; l < 2; l++) for (USHORT m = 0; m < 2; m++) osszeg += tomb[i][j][k][l][m]; cout << "Az összeg: " << osszeg << endl; fVege(); return 0; }
Véletlenszám generálás #include "stdafx.h" #include #include "conio.h" #include //ez kell a véletlenszám generáláshoz using namespace std; typedef unsigned short USHORT; void fMagyar() { setlocale(LC_ALL, "hun"); } void fVege() { cout << endl << "Kilépés..."; _getch(); } void Randomize() { srand(time(NULL)); } USHORT Random(USHORT ertek) { return (rand() % ertek); } //rand() % ertek -- ez egy maradékos osztás, mert az órajelből nagy számot állít elő int main() { fMagyar(); Randomize(); USHORT x; x = Random(10) + 1; //1..10 cout << "A véletlen szám: " << x << endl; x = Random(11) + 5; //5..15 cout << "A véletlen szám: " << x << endl; x = Random(16) + 5; //5..20 cout << "A véletlen szám: " << x << endl; signed short y; y = Random(51) - 20; //-20..30 cout << "A véletlen szám: " << y << endl; float z; z = Random(1000) / 100.0; //0.00..9.99 cout << "A véletlen szám: " << z << endl; z = (Random(5001) - 2000) / 100.0; //-20.00..30.00 cout << "A véletlen szám: " << z << endl; fVege(); return 0; }
61
Számkitalálos játék #include "stdafx.h" #include #include "conio.h" #include using namespace std; typedef unsigned short USHORT; void fMagyar() { setlocale(LC_ALL, "hun"); } void fVege() { cout << endl << "Kilépés..."; _getch(); } void Randomize() { srand(time(NULL)); } USHORT Random(USHORT ertek) { return (rand() % ertek); } int main() { fMagyar(); Randomize(); USHORT kitalalando = Random(101); //0..100 USHORT tippdb = 0; USHORT tipp; cout << "Kitaláltam egy számot (0..100)! Adj meg egy tippet!" << endl; do { cin >> tipp; tippdb++; if (kitalalando > tipp) cout << "Tippelj nagyobbat!" << endl; if (kitalalando < tipp) cout << "Tippelj kisebbet!" << endl; } while (kitalalando != tipp); cout << endl << "Gratulálok! Kitaláltad " << tippdb << "db próbálkozás alatt!" << endl; cout << "A szám amire gondoltunk: " << kitalalando << endl; fVege(); return 0; }
Vektorok használata #include "stdafx.h" #include #include "conio.h" #include //ez a vektorokhoz kell using namespace std; typedef unsigned short USHORT; void fMagyar() { setlocale(LC_ALL, "hun"); } void fVege() { cout << endl << "Kilépés..."; _getch(); } int main() { fMagyar(); vector v; //ez egy dinamikus tömb USHORT x;
62
for (USHORT i = 0; i < 10; i++) { cout << "Add meg a(z) " << i + 1 << ". elemet a vektorba! "; cin >> x; v.push_back(x); //így adhatunk hozzá elemet } v.pop_back(); //ezzel törlöm a dinamikus tömböm utolsó elemét cout << endl << "Töröltük az utolsó elemet!" << endl; for (USHORT i = 0; i < v.size(); i++) //így vizsgálom meg hogy mekkora a tömb cout << "A vektor " << i + 1 << ". eleme: " << v[i] << endl; //így férek hozzá a tömb elemeihez fVege(); return 0; }
Végjelig történő beolvasás 1. #include "stdafx.h" #include #include "conio.h" #include using namespace std; typedef unsigned short USHORT; void fMagyar() { setlocale(LC_ALL, "hun"); } void fVege() { cout << endl << "Kilépés..."; _getch(); } int main() { fMagyar(); vector v; USHORT szam; do { cout << "Addj meg egy elemet a vektorba! "; cin >> szam; v.push_back(szam); } while (szam != 0); //a 0-val lépünk ki a beolvasásból v.pop_back(); //töröljük a kilépő elemet, mert azzal csak kilépni akartunk cout << endl; for (USHORT i = 0; i < v.size(); i++) cout << "A vektor " << i + 1 << ". eleme: " << v[i] << endl; fVege(); return 0; }
Végjelig történő beolvasás 2. #include "stdafx.h" #include #include "conio.h" #include using namespace std; typedef unsigned short USHORT; void fMagyar() { setlocale(LC_ALL, "hun"); } void fVege() { cout << endl << "Kilépés..."; _getch(); }
63
int main() { fMagyar(); vector v; USHORT szam; cout << "Add meg az első elemet! "; cin >> szam; while (szam != 0) { v.push_back(szam); cout << "Add meg a következő elemet! "; cin >> szam; } cout << endl; for (USHORT i = 0; i < v.size(); i++) //ha egyet sem ad meg a felhasználó, akkor nem csinál semmit cout << "A vektor " << i + 1 << ". eleme: " << v[i] << endl; fVege(); return 0; }
Vektor feltöltése véletlenszámokkal végjelig #include "stdafx.h" #include #include "conio.h" #include #include using namespace std; typedef unsigned short USHORT; void fMagyar() { setlocale(LC_ALL, "hun"); } void fVege() { cout << endl << "Kilépés..."; _getch(); } void Randomize() { srand(time(NULL)); } USHORT Random(USHORT ertek) { return (rand() % ertek); } int main() { fMagyar(); Randomize(); vector <signed short> v; signed short szam = Random(201) - 100; while (szam % 10 != 0) //amíg nem osztható 10-el { v.push_back(szam); szam = Random(201) - 100; } v.push_back(szam); //beletehetjük az utolsó (kilépő) elemet is for (USHORT i = 0; i < v.size(); i++) cout << "A vektor " << i + 1 << ". eleme: " << v[i] << endl; fVege(); return 0; }
64
cmath függvények használata #include "stdafx.h" #include #include "conio.h" #include //matematikai számításokhoz using namespace std; typedef unsigned short USHORT; void fMagyar() { setlocale(LC_ALL, "hun"); } void fVege() { cout << endl << "Kilépés..."; _getch(); } double RadToFok(double rad) { return rad * (3.14159265 / 180.0); } //a Pi értékét definiálni kéne int main() { fMagyar(); cout << "6.54321 törtből a törtrész levágása: " << trunc(6.54321) << endl; cout << "|-20|: " << abs(-20) << endl; cout << "Gyök 4: " << sqrt(4) << endl; cout << "Harmadik gyök 27: " << cbrt(27) << endl; cout << "5 a 3.-on: " << pow(5, 3) << endl; cout << "sinus 30 fok: " << sin(RadToFok(30)) << endl; cout << "cosinus 60 fok: " << cos(RadToFok(60)) << endl; cout << "tangens 45 fok: " << tan(RadToFok(45)) << endl; cout << "10-es alapú logaritmus 100: " << log10(100) << endl; cout << "2-es alapú logaritmus 8: " << log2(8) << endl; cout << "Bináris exponenciális 4 (2 az 4.-en): " << exp2(4) << endl; fVege(); return 0; }
Címszerinti paraméterátadás #include "stdafx.h" #include #include "conio.h" #include using namespace std; typedef unsigned short USHORT; void fMagyar() { setlocale(LC_ALL, "hun"); } void fVege() { cout << endl << "Kilépés..."; _getch(); } void Bekeres(vector &v); //címszerinti paraméterátadás void Kiiras(vector v); //egyszerű paraméterátadás int main() { fMagyar(); vector v; Bekeres(v); cout << endl; Kiiras(v); fVege(); return 0; }
65
void Bekeres(vector &v) { USHORT szam; cout << "Add meg az első elemet a vektorba! "; cin >> szam; while (szam != 0) { v.push_back(szam); cout << "Add meg a következő elemet! "; cin >> szam; } } void Kiiras(vector v) { for (USHORT i = 0; i < v.size(); i++) cout << "A vektor " << i + 1 << ". eleme: " << v[i] << endl; }
Prím-e? #include "stdafx.h" #include #include "conio.h" #include using namespace std; typedef unsigned short USHORT; void fMagyar() { setlocale(LC_ALL, "hun"); } void fVege() { cout << endl << "Kilépés..."; _getch(); } bool PrimE(USHORT x); int main() { fMagyar(); USHORT x; cout << "Addj meg egy számot! "; cin >> x; if (PrimE(x)) cout << "A szám prím!" << endl; else cout << "A szám nem prím!" << endl; fVege(); return 0; } bool PrimE(USHORT x) { USHORT i = 2; while ((i <= sqrt(x)) && (x % i != 0)) i++; return (i > sqrt(x)); }
66
Faktoriális számítása #include "stdafx.h" #include #include "conio.h" using namespace std; typedef unsigned long ULONG; void fMagyar() { setlocale(LC_ALL, "hun"); } void fVege() { cout << endl << "Kilépés..."; _getch(); } ULONG Faktorialis(ULONG x); int main() { fMagyar(); ULONG x; cout << "Addj meg egy számot! "; cin >> x; cout << "A szám faktoriálisa: " << Faktorialis(x) << endl; fVege(); return 0; } ULONG Faktorialis(ULONG x) { if (x == 1) return 1; else return (x * Faktorialis(x - 1)); //folyamatosan önmagát meghívja a függvény }
Várakozás és a képernyő törlése #include "stdafx.h" #include #include "conio.h" using namespace std; void fMagyar() { setlocale(LC_ALL, "hun"); } void fVege() { cout << endl << "Kilépés..."; _getch(); } void Varakoz() { system("pause"); } //vár egy gomb lenyomásig void ClrScr() { system("cls"); } //képernyő törlése int main() { fMagyar(); for (unsigned short i = 0; i < 10; i++) cout << "ggrjigfirfbhefrti e ewherberenjrnéltlz rtrjek" << endl; Varakoz(); //belevan építve egy szöveg kiírás is //cout << "A képernyő törléséhez nyomj le egy gombot! "; //_getch(); //ez a módszer szerintem sokkal jobb ClrScr(); cout << "Sikeresen törölte a képernyő tartalmát!" << endl; fVege(); return 0; }
67
String és char alapok #include "stdafx.h" #include #include "conio.h" #include <string> //kell a stringhez using namespace std; void fMagyar() { setlocale(LC_ALL, "hun"); } void fVege() { cout << endl << "Kilépés..."; _getch(); } void Varakoz() { _getch(); } void ClrScr() { system("cls"); } int main() { fMagyar(); string x, y; //így deklarálok egy stringet char ch = ','; //így deklarálok egy char-t cout << "Adj meg egy szöveget! "; getline(cin, x); //így olvasok be egy teljes sort, mert a cin csak szóközig olvas cout << x << endl; cout << "A szöveg karaktereinek a száma: " << x.size() << endl; //str.size() = str.length() cout << "Adj meg egy másik szöveget! "; getline(cin, y); x += y; //2 string összefüzése, ez a legegyszerűbb x.push_back(ch); //karakter hozzáfűzése a stringhez x.append(y); //y hozzátűzése az x-hez cout << "A két szöveg: " << x << endl; x.clear(); cout << "A string tartalma: " << x << endl; cout << endl << "A képernyő törléséhez nyomj le egy gombot! "; Varakoz(); ClrScr(); cout << "Adj meg egy szót! "; cin >> x; //ez csak szóközig olvas cout << "Adj meg még egy szót! "; cin >> y; if (x < y) //így hasonlítok össze két stringet cout << "Az első szó van előrébb az abcben!" << endl; else cout << "Nem az első szó van előrébb az abcben!" << endl; fVege(); return 0; }
A string karaktereihez való hozzáférés #include "stdafx.h" #include #include "conio.h" #include <string> //ez kell a getline miatt using namespace std; void fMagyar() { setlocale(LC_ALL, "hun"); } void fVege() { cout << endl << "Kilépés..."; _getch(); }
68
int main() { fMagyar(); string nev; cout << "Add meg a neved! "; getline(cin, nev); cout << "A megadott név visszafelé: "; for (unsigned short i = nev.size(); i >= 1; i--) cout << nev[i - 1]; //azért i - 1, mert a string karakterei 0..255-ig helyezkedhetnek el cout << endl; fVege(); return 0; }
String függvények használata 1. #include "stdafx.h" #include #include "conio.h" #include <string> //ez kell a string függvényekhez using namespace std; typedef unsigned short USHORT; void fMagyar() { setlocale(LC_ALL, "hun"); } void fVege() { cout << endl << "Kilépés..."; _getch(); } int main() { fMagyar(); string str; cout << "Adj meg egy szöveget! "; getline(cin, str); /* str[0] = tolower(str[0]); //kisbetűssé alakítja az első karaktert cout << str << endl; str[1] = toupper(str[1]); //nagybetűssé alakítja az második karaktert cout << str << endl; */ if (islower(str[0])) //ha az első karakter kicsi, csak betűk esetében működik cout << "Nem kezdted helyesen a mondatot!" << endl; else cout << "Helyesen kezdted a mondatot!" << endl; if (isupper(str[0])) //ha az első karakter nagy, csak betűk esetében működik cout << "Helyesen kezdted a mondatot!" << endl; else cout << "Nem kezdted helyesen a mondatot!" << endl; USHORT szamok = 0; USHORT betuk = 0; USHORT szam_betu = 0; USHORT helykitoltok = 0; USHORT irasjelek = 0; for (USHORT i = 0; i < str.size(); i++) { if (isdigit(str[i])) //ha az adott karakter egy szám szamok++; if (isalpha(str[i])) //ha az adott karakter egy betű betuk++; if (isalnum(str[i])) //ha az adott karakter egy szám vagy egy betű szam_betu++;
69
if (isspace(str[i])) //ha az adott karakter space, TAB, vagy hasonló helykitoltok++; if (ispunct(str[i])) //ha az adott karakter egy írásjel irasjelek++; } cout << "A mondatban lévő számok száma: " << szamok << endl; cout << "A mondatban lévő betűk száma: " << betuk << endl; cout << "A mondatban lévő egyéb karakterek száma: " << str.size() - szam_betu << endl; cout << "A mondatban lévő helykitöltő karakterek száma: " << helykitoltok << endl; cout << "A mondatban lévő írásjelek száma: " << irasjelek << endl; fVege(); return 0; }
Zárójelek megfelelő használatának vizsgálata #include "stdafx.h" #include #include "conio.h" #include <string> using namespace std; void fMagyar() { setlocale(LC_ALL, "hun"); } void fVege() { cout << endl << "Kilépés..."; _getch(); } bool Zarojel(string str); int main() { fMagyar(); string str; cout << "Addj meg egy sort!" << endl; getline(cin, str); if (Zarojel(str) == true) cout << "Jó a zárójelezés!" << endl; else cout << "Nem jó a zárójelezés!" << endl; fVege(); return 0; } bool Zarojel(string str) { signed short zarojel = 0; unsigned short i = 0; while ((i < str.size()) && (zarojel >= 0)) { if (str[i] == '(') zarojel++; if (str[i] == ')') zarojel--; i++; } if (zarojel == 0) return true; else return false; }
70
Monogramm készítés #include "stdafx.h" #include #include "conio.h" #include <string> using namespace std; void fMagyar() { setlocale(LC_ALL, "hun"); } void fVege() { cout << endl << "Kilépés..."; _getch(); } string Monogramm(string nev); int main() { fMagyar(); string nev; cout << "Addj meg egy nevet!" << endl; getline(cin, nev); nev = Monogramm(nev); if (nev != "Hiba!") cout << "A név monogrammja: " << nev << endl; else cout << "A név nem megfelelő!" << endl; fVege(); return 0; } string Monogramm(string nev) { string mono = ""; unsigned short i; if (isalpha(nev[0])) mono += toupper(nev[0]); for (i = 0; i < nev.size() - 1; i++) if ((isspace(nev[i])) && (isalpha(nev[i + 1]))) mono += toupper(nev[i + 1]); i = 0; while ((i < nev.size()) && (mono != "Hiba!")) { if ((isdigit(nev[i])) || (ispunct(nev[i]))) //ha van benne szám, vagy írásjel mono = "Hiba!"; i++; } return mono; }
String függvények használata 2. #include "stdafx.h" #include #include "conio.h" #include <string> using namespace std; void fMagyar() { setlocale(LC_ALL, "hun"); } void fVege() { cout << endl << "Kilépés..."; _getch(); }
71
int main() { fMagyar(); unsigned short k; string str, str2 = "alma"; cout << "Addj meg egy stringet!" << endl; getline(cin, str); if (str.size() >= 4) str.insert(3, str2); //beszúrjuk a 4. helyre else str.insert(0, str2); //különben az 1. helyre a hiba elkerülése végett cout << str << endl; str.insert(3, 5, 'n'); //beszúrunk a 4. helyre 5db n betűt cout << str << endl; str.erase(3, 2); //kitöröljuk a 4. helytől számítva 2 karaktert cout << str << endl; str2 = str.substr(5, 4); //a string 6. helyétől számítva 4 karaktert add vissza cout << str2 << endl; //muszáj valamihez csatolni str.replace(3, 2, "alma"); //a string 4. helyétől számítva 2 karaktert töröl cout << str << endl; //és a helyére rakja az "alma"-t str.replace(1, 0, 3, '.'); //a string 2. helyétől számítva 0 karaktert töröl cout << str << endl; //és a helyére szúr 3db '.' karaktert str = "almakortealma"; //a további függvényekhez str2 = "alma"; k = str.find(str2); //legelőször hanyadik helyen fordul elő az str-ben az str2 cout << "Legelőször a " << k + 1 << ". helyen fordul elő!" << endl; k = str.find(str2, 4); //legelőször hanyadik helyen fordul elő az str-ben az str2 az 5. helytől cout << "Legelőször a " << k + 1 << ". helyen fordul elő!" << endl; k = str.find('a'); //legelőször hanyadik helyen fordul elő az 'a' karakter cout << "Legelőször a " << k + 1 << ". helyen fordul elő!" << endl; k = str.find('a', 5); //legelőször hanyadik helyen fordul elő az 'a' karakter az 5. helytől cout << "Legelőször a " << k + 1 << ". helyen fordul elő!" << endl; k = str.rfind(str2); //legutoljára hanyadik helyen fordul elő az str-ben az str2 cout << "Legutoljára a " << k + 1 << ". helyen fordul elő!" << endl; k = str.rfind(str2, 10); //legutoljára hanyadik helyen fordul elő az str-ben az str2 az 11. helyig cout << "Legutoljára a " << k + 1 << ". helyen fordul elő!" << endl; k = str.rfind('a'); //legutoljára hanyadik helyen fordul elő az 'a' karakter cout << "Legutoljára a " << k + 1 << ". helyen fordul elő!" << endl; k = str.rfind('a', 5); //legutoljára hanyadik helyen fordul elő az 'a' karakter az 6. helyig cout << "Legutoljára a " << k + 1 << ". helyen fordul elő!" << endl; fVege(); return 0; }
72
Input String Stream és Output String Stream 1. #include "stdafx.h" #include #include "conio.h" #include <string> #include <sstream> //ez a konvertáláshoz kell #include using namespace std; typedef unsigned short USHORT; void fMagyar() { setlocale(LC_ALL, "hun"); } void fVege() { cout << endl << "Kilépés..."; _getch(); } void Beker(string &x); void Kiir(vector v); void StringToVektor(vector &v, string x); void VektorToString(vector v, string &x); int main() { fMagyar(); string x; vector v; Beker(x); StringToVektor(v,x); Kiir(v); VektorToString(v, x); cout << "A string tartalma: " << x << endl; fVege(); return 0; } void Beker(string &x) { cout << "Addj meg egy számsort! "; getline(cin, x); } void Kiir(vector v) { for (USHORT i = 0; i < v.size(); i++) cout << "A vektor " << i + 1 << ". eleme: " << v[i] << endl; } void StringToVektor(vector &v, string x) { istringstream szamok(x); //az x-ből csinálunk egy adatfolyamot, Input String Stream signed short szam; //csak akkor működik ha a számokon kívül csak kitöltő karaltereket használunk while (szamok >> szam) //amíg van adat még az adatfolyamban, addig beleteszi a szam-ba if (szam >= 0) //csak a pozitív számokat tesszük bele v.push_back(szam); //itt beletesszük a vektorba } void VektorToString(vector v, string &x) { x.clear(); //törölni kell a string tartalmát ostringstream szamStr(x); //ez az OutPut String Stream for (USHORT i = 0; i < v.size(); i++) szamStr << v[i] << " "; //stringbe így tehetünk számot x = szamStr.str(); //ez az x-et egyenlővé teszi a stringes adatfolyammal x.erase(x.size() - 1, 1); //törlöm a stringből az utolsó szóközt }
73
Input String Stream és Output String Stream 2. #include "stdafx.h" #include #include "conio.h" #include <sstream> using namespace std; void fMagyar() { setlocale(LC_ALL, "hun"); } void fVege() { cout << endl << "Kilépés..."; _getch(); } void Vizsgal(string &x); int main() { fMagyar(); string x; cout << "Addj meg egy számsort! "; getline(cin, x); Vizsgal(x); if (x != "0") cout << "Van a számok között negatív is!" << endl; else cout << "Nincs benne negatív szám!" << endl; fVege(); return 0; } void Vizsgal(string &x) { istringstream szamok(x); x.clear(); ostringstream vissza(x); signed short szam; while ((szamok >> szam) && (szam >= 0)) //van-e benne negatív szám { /*üres ciklusmag*/ } bool van = szam < 0; //negatív számot olvastunk-e be utoljára vissza << van; x = vissza.str(); }
Fájlkezelés #include "stdafx.h" #include #include "conio.h" #include #include #include <string> using namespace std; void fMagyar() { setlocale(LC_ALL, "hun"); } void fVege() { cout << endl << "Kilépés..."; _getch(); } void Beolvas(vector <string> &v); void KiirFile(vector <string> v); int main() { fMagyar();
74
vector <string> v; Beolvas(v); KiirFile(v); cout << "A fájl sikeresen másolva!" << endl; fVege(); return 0; } void Beolvas(vector <string> &v) { string sor; ifstream fin("szoveg.txt"); //Input File Stream, csatolom a txt-t while (!fin.eof()) //amíg nincs vége a File-nak { getline(fin, sor); //így olvasok be egy sort v.push_back(sor); //hozzáadom a vektorhoz az adott sort } fin.close(); //leválasztom a csatolt txt-t } void KiirFile(vector <string> v) { ofstream fout("masolat.txt"); //Output File Stream //csatolom a txt-t felülírásra, ha nincs ilyen akkor létrehozza magától for (unsigned short i = 0; i < v.size(); i++) fout << v[i] << endl; //így tudok beleírni a File-ba fout.close(); //leválasztom a csatolt txt-t }
Fájlkezelés 2. #include "stdafx.h" #include #include "conio.h" #include #include <sstream> using namespace std; int main() { setlocale(LC_ALL, "hun"); string sor; ifstream fin("szoveg.txt"); ofstream fout("max.txt"); while (!fin.eof()) { getline(fin, sor); if (sor.size() == 0) fout << "Nincs a sorban szám!" << endl; else { istringstream szamok(sor); signed long szam, max; szamok >> max; while (szamok >> szam) if (szam > max) max = szam; fout << max << endl; } }
75
fin.close(); fout.close(); cout << "Kilépés..."; _getch(); return 0; }
string to int, int to string #include "stdafx.h" #include #include "conio.h" #include <string> //ez kell a konvertáláshoz using namespace std; int main() { setlocale(LC_ALL, "hun"); unsigned short szam = 123; string szoveg = to_string(szam); //int to string cout << "A szám értéke: " << szam << endl; cout << "A szöveg értéke: " << szoveg << endl; szoveg = "456"; szam = stoi(szoveg); //string to int cout << "A szöveg értéke: " << szoveg << endl; cout << "A szám értéke: " << szam << endl; cout << "Kilépés..."; _getch(); return 0; }
Dátum és idő lekérdezése és használata #include "stdafx.h" #include #include "conio.h" #include <string> //konvertáláshoz #include <windows.h> //ez kell a dátum lekérdezéshez using namespace std; typedef unsigned short USHORT; int main() { setlocale(LC_ALL, "hun"); SYSTEMTIME most; //idő típus deklarálása GetLocalTime(&most); //a rendszeridő lekérése USHORT ev = most.wYear; //így külön tudom venni a dátum és idő értékeit USHORT honap = most.wMonth; USHORT nap = most.wDay; USHORT napaheten = most.wDayOfWeek; USHORT ora = most.wHour; USHORT perc = most.wMinute; USHORT mperc = most.wSecond;
76
USHORT millimperc = most.wMilliseconds; string datum = "", ido = ""; datum = to_string(ev) + '.'; if (honap / 10 < 1) //ha nem kétjegyű datum += "0"; datum += to_string(honap) + '.'; if (nap / 10 < 1) //ha nem kétjegyű datum += "0"; datum += to_string(nap) + '.'; if (ora / 10 < 1) //ha nem kétjegyű ido += "0"; ido += to_string(ora) + ':'; if (perc / 10 < 1) //ha nem kétjegyű ido += "0"; ido += to_string(perc) + ':'; if (mperc / 10 < 1) //ha nem kétjegyű ido += "0"; ido += to_string(mperc) + '.'; if (millimperc / 100 < 1) //ha nem háromjegyű ido += "0"; if (millimperc / 10 < 1) //ha nem kétjegyű ido += "0"; ido += to_string(millimperc); cout << datum << " " << ido << endl; cout << "Ez a hét " << napaheten << ". napja!" << endl; cout << "Kilépés..."; _getch(); return 0; }
GotoXY és a színes betűk használata #include "stdafx.h" #include #include "conio.h" #include <windows.h> //ez kell a GotoXY-hoz using namespace std; typedef unsigned short USHORT; void GotoXY(USHORT y, USHORT x) //mivel a c++-ba nincs beépítve ezért külön írnunk kell egy függvényt rá { COORD coord; coord.X = x; coord.Y = y; SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), coord); } int main() { setlocale(LC_ALL, "hun"); //most lekérem az alapértelmezett betűszínt WORD regiszin; CONSOLE_SCREEN_BUFFER_INFO csbiInfo; GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbiInfo); regiszin = csbiInfo.wAttributes;
77
USHORT sor = 0, vege = 0; //ezzel számolom hogy hanyadik sorban járok cout << "Ez az első sor!" << endl; cout << "Ez a második sor!" << endl; cout << "Ez a harmadik sor!" << endl; cout << "Ez a negyedik sor!" << endl; vege = sor = 4; //úgyanazt adom a vege és sor változónak is //eddig alapértelmezett volt a betűk színe, most átírunk a GotoXY használatával pár szót más színnel SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_GREEN | FOREGROUND_INTENSITY); //zöld sor = 1; //2. sor GotoXY(sor, 5); //6. oszlop cout << "második"; SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_RED | FOREGROUND_INTENSITY); //piros sor = 3; //4. sor GotoXY(sor, 14); //14. oszlop cout << "sor"; SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_BLUE | FOREGROUND_INTENSITY); //kék sor = 0; //1. sor GotoXY(sor, 0); //0. oszlop cout << "Ez az"; GotoXY(vege, 0); //a legutolsó sorba ugrunk //a következő rész kiírja színessel a szín számát /*for(int colour = 0x00; colour <= 0xff; colour++) { SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), colour); cout << "Using colour:" << colour << endl; cin.get(); }*/ SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 12); //így is meglehet adni a színt cout << "Ez most píros színű!" << endl; SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), regiszin); //visszaállítom a régi színt cout << "A régi szín száma: " << regiszin << endl; cout << "Kilépés..."; _getch(); return 0; }
Pénzügyi helyzet kiértékelése #include "stdafx.h" #include #include "conio.h" #include #include #include <string> using namespace std; typedef signed long ULONG; void Beolvas(vector &v); void Szamolas(vector &v, ULONG &koltott, ULONG &kapott);
78
int main() { setlocale(LC_ALL, "hun"); vector v; Beolvas(v); ULONG koltott = 0, kapott = 0; Szamolas(v, koltott, kapott); cout << "Az első összeg: " << v[0] << " Ft" << endl; cout << "Az utolsó összeg: " << v[v.size() - 1] << " Ft" << endl; cout << "A kapott pénzek összege: " << kapott << " Ft" << endl; cout << "Az összes elköltött pénz: " << koltott << " Ft" << endl; cout << "Összesen " << v[v.size() - 1] + koltott << " Ft-om volt ez alatt az idő alatt!"; _getch(); return 0; } void Beolvas(vector &v) { string sor; ULONG osszeg; ifstream fin("vagyonlista.txt"); while (!fin.eof()) { getline(fin, sor); osszeg = stoi(sor); v.push_back(osszeg); } fin.close(); } void Szamolas(vector &v, ULONG &koltott, ULONG &kapott) { for (unsigned short i = 1; i < v.size() - 1; i++) { if (v[i] < v[i - 1]) koltott += v[i - 1] - v[i]; if (v[i] > v[i - 1]) kapott += v[i] - v[i - 1]; } }
Saját függvények használata //ez a sajatfugg.hpp fájl tartalma #include "stdafx.h" #include #include "conio.h" #include <windows.h> #include void ClrScr() { system("cls"); } void fMagyar() { setlocale(LC_ALL, "hun"); } void Varakoz() { _getch(); } void fVege() { std::cout << std::endl << "Kilépés..."; _getch(); } void Randomize() { srand(time(NULL)); } unsigned short Random(unsigned short ertek) { return (rand() % ertek); } void BetuAlap() { SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 7); } void BetuZold() { SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 10); } void BetuPiros() { SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 12); } void BetuSarga() { SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 14); }
79
void BetuFeher() { SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 15); } void GotoXY(unsigned short y, unsigned short x) { COORD coord; coord.X = x; coord.Y = y; SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), coord); }
//ez a jelenlegi program tartalma #include "stdafx.h" //ez kötelező #include "sajatfugg.hpp" //így feltudom használni a saját függvényeimet using namespace std; int main() { BetuZold(); fMagyar(); Randomize(); cout << "Hello Word!"; Varakoz(); GotoXY(5, 0); BetuPiros(); cout << Random(20) << endl; BetuAlap(); fVege(); return 0; }
Kétdimenziós vektor használata #include "stdafx.h" //ez kötelező #include "sajatfugg.hpp" //így feltudom használni a saját függvényeimet #include //ez a vektohoz kell using namespace std; int main() { fMagyar(); vector < vector > tomb; //így deklarálok egy kétdimenziósvektort vector seged; //ez egy dimenziós vektor tomb.push_back(seged); //létrehozok a vektorban egy sort tomb[0].push_back(21); //a sorba beleteszem a 21 34 44 számokat tomb[0].push_back(34); tomb[0].push_back(44); cout << tomb[0][1] << endl; //kiírom a 34-et, ami az 1. sor 2. eleme tomb.push_back(seged); //újabb sort hozok létre tomb[1].push_back(17); //21 34 44 tomb[1].push_back(35); //17 35 67 93 tomb[1].push_back(67); tomb[1].push_back(93); cout << tomb[1][2] << endl; //kiírom a 67-et, ami a 2. sor 3. eleme seged.push_back(11); //az egydimenziós tömbben: 11 42 8 seged.push_back(42); seged.push_back(8); cout << seged[1] << endl; //kiírom a 2. elemet, ami a 42 tomb[1] = seged; //hozzárendelem a seged-et a 2. sorhoz,
80
fVege(); //így 17 35 67 93 helyett 11 42 8 lesz abban a "sorban" return 0; }
Beep használata #include "stdafx.h" #include <Windows.h> //ez a Beep-hez kell int main() { Beep(2000, 500); //bizonyos frekvenciájú, bizonyos ideig történő hang lejátszása Beep(2200, 500); Beep(2400, 500); Beep(2600, 500); Beep(2800, 500); Beep(3000, 500); system("pause"); return 0; }
Hivatkozások használata #include "stdafx.h" #include using namespace std; int main() { int intOne; //int = signed long int &rSomeRef = intOne; //a & a hivatkozás deklarálásához kell //hivatkozás = egy másik névvel hivatkozunk az eredetire //a hivatkozás nem mutathat másra, csak amire inicializáltuk intOne = 5; //ha ezt megváltoztatom, akkor rSomeRef is változni fog, mert az erre mutat cout << "intOne: " << intOne << endl; cout << "rSomeRef: " << rSomeRef << endl; rSomeRef = 7; //ha ezt megváltoztatom, akkor intOne is megváltozik cout << "intOne: " << intOne << endl; cout << "rSomeRef: " << rSomeRef << endl; system("pause"); return 0; }
Címe operátor és a hivatkozás operátor #include "stdafx.h" #include using namespace std;
81
int main() { int intOne; int &rSomeRef = intOne; //a & a hivatkozás operátora intOne = 5; cout << "intOne: " << intOne << endl; cout << "rSomeRef: " << rSomeRef << endl; cout << "&intOne: " << &intOne << endl; //a & a címe operátor cout << "&rSomeRef: " << &rSomeRef << endl; system("pause"); return 0; }
Cím szerinti paraméterátadás mutatókkal #include "stdafx.h" #include using namespace std; void Csere(int *x, int *y); //a "*" mondja a függvénynek, hogy ez egy mútató int main() { int x = 5, y = 10; cout << "Main. Csere elott, x:" << x << " y:" << y << endl; Csere(&x, &y); //így adom át az értékeket cout << "Main. Csere utan, x:" << x << " y:" << y << endl; system("pause"); return 0; } void Csere(int *px, int *py) //ez lehetne *x és *y is { int seged; cout << "Csere. Csere elott, *px:" << *px << " *py:" << *py << endl; seged = *px; //így tudok velük műveletet végezni *px = *py; *py = seged; cout << "Csere. Csere utan, *px:" << *px << " *py:" << *py << endl; }
Cím szerinti paraméterátadás hivatkozásokkal //ez a megoldás sokkal jobb, mint a mutatós megoldás #include "stdafx.h" #include using namespace std; void Csere(int &x, int &y); //a & mondja a függvénynek, hogy ez egy hivatkozás int main() { int x = 5, y = 10; cout << "Main. Csere elott, x:" << x << " y:" << y << endl; Csere(x, y); //a paramétereket átadni is egyszerűbb
82
cout << "Main. Csere utan, x:" << x << " y:" << y << endl; system("pause"); return 0; } void Csere(int &rx, int &ry) //ez lehetne &x és &y is { int seged; cout << "Csere. Csere elott, rx:" << rx << " ry:" << ry << endl; seged = rx; //a műveletvégzés is egyszerűbb, mint a mutatókkal rx = ry; ry = seged; cout << "Csere. Csere utan, rx:" << rx << " ry:" << ry << endl; }
Több érték visszaadása #include "stdafx.h" #include using namespace std; typedef unsigned short USHORT; typedef unsigned long ULONG; enum HIBA_KOD { FASZA, KIS_SZAM, NAGY_SZAM }; //ez egy felsorolt típus, amit a hibajelzésre fogok használni HIBA_KOD Factor(USHORT, ULONG &, ULONG &); //így lesz egy visszatérési érték + a 2 hivatkozás is int main() { USHORT szam; ULONG squared, cubed; HIBA_KOD hiba; cout << "Adj meg egy szamot (10-20): "; cin >> szam; hiba = Factor(szam, squared, cubed); if (hiba == FASZA) //ha jó számot adtunk meg { cout << "szam: " << szam << endl; cout << "negyzete: " << squared << endl; cout << "kobe: " << cubed << endl; } if (hiba == KIS_SZAM) //ha kisebb számot adtál meg cout << "10-nel kisebb szamot adtal meg!!!" << endl; if (hiba == NAGY_SZAM) //ha nagyobb számot adtál meg cout << "20-nal nagyobb szamot adtal meg!!!" << endl; system("pause"); return 0; } HIBA_KOD Factor(USHORT szam, ULONG &squared, ULONG &cubed) { HIBA_KOD ertek = FASZA; //alapként legyen jó //hibaellenőrzések sora if (szam > 20) ertek = NAGY_SZAM; //ha hiba van, akkor legyen rossz if (szam < 10) ertek = KIS_SZAM;
83
if (ertek == FASZA) //ha minden kritikának eleget tesz, akkor fasza { squared = szam * szam; cubed = szam * szam * szam; } return ertek; }
Osztályok és objektumok használata #include "stdafx.h" #include using namespace std; class Cica //így deklarálok egy osztályt { public: //publikus rész void Nyavogas() //helyben kifejtett függvény { cout << "Miau. Miau." << endl << "Miau. Mi..." << endl << "Ne nyavogj!!!" << endl; } }; int main() { Cica Cirmi; //így deklarálok egy objektumot Cirmi.Nyavogas();//így hívom meg az osztály függvényét system("pause"); return 0; }
Privát változó használata az osztályban #include "stdafx.h" #include using namespace std; typedef unsigned short USHORT; class Teglalap { public: //publikus rész void OldalMegad(USHORT szam1, USHORT szam2) { a = szam1; b = szam2; } USHORT KapKerulet() { return kerulet; } unsigned long KapTerulet() { return terulet; } void Szamol() { kerulet = 2 * (a + b); terulet = a * b; } private: //private rész USHORT a; USHORT b; USHORT kerulet; unsigned long terulet; };
84
int main() { USHORT szam1, szam2; cout << "Add meg a teglalap oldalait!" << endl; cin >> szam1; cin >> szam2; Teglalap teglalap; teglalap.OldalMegad(szam1, szam2); //így adom át az osztály függvényének teglalap.Szamol(); //elvégzem a számításokat, majd kiíratom az adatokat cout << "A teglalap ket oldala: " << szam1 << ", " << szam2 << endl; cout << "A teglalap kerulete: " << teglalap.KapKerulet() << endl; cout << "A teglalap terulete: " << teglalap.KapTerulet() << endl; system("pause"); return 0; }
Objektum Orientált Programozás //main.cpp fájl #include "stdafx.h" #include #include <string> //ez kell pár dologhoz #include "Tanulo.h" using namespace std; int main() { string nev; unsigned short magassag; double suly; cout << "Add meg a tanulo nevet!" << endl; getline(cin, nev); cout << "Add meg a tanulo magassagat! (cm)" << endl; cin >> magassag; cout << "Add meg a tanulo testsulyjat! (kg)" << endl; cin >> suly; Tanulo Tanulo_1(nev, magassag, suly); cout << "A tanulo neve: " << Tanulo_1.KapNev() << endl; cout << "A tanulo magassaga: " << Tanulo_1.KapMagassag() << " cm" << endl; cout << "A tanulo sulya: " << Tanulo_1.KapSuly() << " kg" << endl; system("pause"); return 0; }
//Tanulo.h fájl #ifndef TANULO_H #define TANULO_H class Tanulo { public: Tanulo(); //üres konstruktor Tanulo(string, unsigned short, double); //kezdőértékes konstruktor, függvénytúlterhelés alkalmazása string KapNev() const; unsigned short KapMagassag() const; double KapSuly() const;
85
private: string ujnev; unsigned short ujmagassag; double ujsuly; }; #endif
//Tanulo.cpp fájl #include "stdafx.h" #include "Tanulo.h" Tanulo::Tanulo() { ujnev = ""; ujmagassag = 0; ujsuly = 0.0; //valós típus } Tanulo::Tanulo(string nev, unsigned short magassag, double suly) { ujnev = nev; ujmagassag = magassag; ujsuly = suly; } string Tanulo::KapNev() const { return ujnev; } unsigned short Tanulo::KapMagassag() const { return ujmagassag; } double Tanulo::KapSuly() const { return ujsuly; }
Konstans mutató átadása függvénynek #include "stdafx.h" #include using namespace std; typedef unsigned short USHORT; class SimpleCat { public: SimpleCat(); //konstruktor SimpleCat(SimpleCat&); //másoló konstruktor, ez most nem kerül meghívásra, de van ilyen is ~SimpleCat(); //destructor USHORT GetAge() const { return itsAge; } void SetAge(USHORT age) { itsAge = age; } private: USHORT itsAge; };
86
SimpleCat::SimpleCat() //ez az objektum létrehozásakor fut le { cout << "Simple Cat Constructor..." << endl; itsAge = 1; } SimpleCat::SimpleCat(SimpleCat&) //ez az objektum paraméter átadással történő létrehozásakor fut le { cout << "Simple Cat Copy Constructor..." << endl; } SimpleCat::~SimpleCat() //ez az objektum törlésekor fut le { cout << "Simple Cat Destructor..." << endl; } //a következő sorban egy konstans objektumra utaló konstans mutató paraméterátadása található const SimpleCat * const FunctionTwo(const SimpleCat * const theCat); //ez a deklarálása int main() { cout << "Making a cat..." << endl; SimpleCat Frisky; //létrehozunk egy macskát cout << "Frisky is " << Frisky.GetAge() << " years old" << endl; USHORT age = 5; Frisky.SetAge(age); //beállítjuk az életkorát cout << "Frisky is " << Frisky.GetAge() << " years old" << endl; cout << "Calling FunctionTwo..." << endl; FunctionTwo(&Frisky); //így adom át a mutatónak az objektumot cout << "Frisky is " << Frisky.GetAge() << " years old" << endl; system("pause"); return 0; } const SimpleCat * const FunctionTwo(const SimpleCat * const theCat) //konstans mutatót kap és ad vissza { cout << "Function Two. Returning..." << endl; cout << "Frisky is now " << theCat->GetAge() << " years old" << endl; //theCat->SetAge(8); //konstans mutatóval nem hívhatunk meg nem konstans függvényt return theCat; }
Konstans hivatkozások átadása függvénynek //a hivatkozások sokkal jobban átláthatóbbak és használhatóak, mint a mutatók //ha a program futása közben változtatni szeretnénk a célobjektumon, akkor mutatót kell használni //ha a program futasa közben a célobjektum nullázodhat, akkor mutatót kell használni //ha a dinamikus memóriában tároljuk az objektumokat, akkor mutatót kell használni #include "stdafx.h" #include using namespace std; typedef unsigned short USHORT; class SimpleCat { public: SimpleCat(); SimpleCat(SimpleCat&); ~SimpleCat();
87
USHORT GetAge() const { return itsAge; } void SetAge(USHORT age) { itsAge = age; } private: USHORT itsAge; }; SimpleCat::SimpleCat() { cout << "Simple Cat Constructor..." << endl; itsAge = 1; } SimpleCat::SimpleCat(SimpleCat&) { cout << "Simple Cat Copy Constructor..." << endl; } SimpleCat::~SimpleCat() { cout << "Simple Cat Destructor..." << endl; } const SimpleCat & FunctionTwo(const SimpleCat &theCat); //konstans hivatkozásokkal dolgozunk int main() { cout << "Making a cat..." << endl; SimpleCat Frisky; //létrehozunk egy macskát cout << "Frisky is " << Frisky.GetAge() << " years old" << endl; USHORT age = 5; Frisky.SetAge(age); //beállítjuk az életkorát cout << "Frisky is " << Frisky.GetAge() << " years old" << endl; cout << "Calling FunctionTwo..." << endl; FunctionTwo(Frisky); //így adom át a hivatkozásnak az objektumot cout << "Frisky is " << Frisky.GetAge() << " years old" << endl; system("pause"); return 0; } const SimpleCat & FunctionTwo(const SimpleCat &theCat) //konstans mutatót kap és ad vissza { cout << "Function Two. Returning..." << endl; cout << "Frisky is now " << theCat.GetAge() << " years old" << endl; //theCat.SetAge(8); //konstans hivatkozással nem hívhatunk meg nem konstans függvényt return theCat; }
Mutató, mint a függvény visszatérési értéke #include "stdafx.h" #include using namespace std; class SimpleCat { public: SimpleCat(int age) { itsAge = age; } ~SimpleCat() { /*üres*/ } int GetAge() { return itsAge; }
88
private: int itsAge; }; SimpleCat * TheFunction(); //egy mutatót fog visszaadni a függvény int main() { SimpleCat *pFrisky = TheFunction(); //a létrehozott objektumot hozzárendelem egy mutatóhoz cout << "pFrisky is " << pFrisky->GetAge() << " years old!" << endl; cout << "pFrisky: " << pFrisky << endl; //kiírom az objektum címét system("pause"); return 0; } SimpleCat * TheFunction() //ez egy objektumot létrehozó függvény { SimpleCat *pCat = new SimpleCat(5); //5 éves macska létrehozása a dinamikus memóriába cout << "pCat: " << pCat << endl; //kiírom a mutató címét return pCat; //visszaadom az objektumra mutató mutatót }
Alapértelmezett értékek, túlterhelt tagfüggvények és konstruktorok #include "stdafx.h" #include using namespace std; class Rectangle { public: Rectangle() {} //konstruktor túlterhelése Rectangle(int width, int height); ~Rectangle() { } //a desktruktort nem lehet túlterhelni void DrawShape() const; //tagfüggvény túlterhelése void DrawShape(int aWidth, int aHeight) const; //a függvénytúlterheléses módszert ajánlott használni void NewDrawShape(int aWidth, int aHeight, bool UseCurrentVals = false) const; //alapértelmezett érték private: int itsWidth = 1; //kezdőérték adás int itsHeight = 1; //ez arra jó ha nem inicializáljuk, akkor is lesz értéke }; Rectangle::Rectangle(int width, int height) { itsWidth = width; itsHeight = height; } void Rectangle::DrawShape() const { //programot úgy írjunk, hogy kódrészletet lehetőleg ne ismételjünk DrawShape(itsWidth, itsHeight); //a másik függvényt hívom meg az osztály változóival }
89
void Rectangle::DrawShape(int width, int height) const { for (int i = 0; i < height; i++) { for (int j = 0; j < width; j++) cout << "*"; cout << endl; } } void Rectangle::NewDrawShape(int width, int height, bool UseCurrentValue) const { int printWidth; int printHeight; if (UseCurrentValue == true) { printWidth = itsWidth; //használja az osztály pillanatnyi értékeit printHeight = itsHeight; } else { printWidth = width; //használja a megadott paramétereket printHeight = height; } /*for (int i = 0; i < printHeight; i++) { for (int j = 0; j < printWidth; j++) cout << "*"; cout << endl; }*/ DrawShape(printWidth, printHeight); //programot úgy írjunk, hogy kódrészletet lehetőleg ne ismételjünk } int main() { Rectangle theRect(30, 5); //30;5-re inicializáljuk az egyik téglalapot cout << "DrawShape():" << endl; theRect.DrawShape(); //ez az osztályértékekkel dolgozik (30;5) cout << endl << "DrawShape(40,2):" << endl; theRect.DrawShape(40, 2); //itt az átadott értékekkel dolgozik cout << endl << "NewDrawShape(0,0,true)..." << endl; theRect.NewDrawShape(0, 0, true); //ha a harmadik igaz, akkor az első kettő érték lényegtelen cout << endl << "NewDrawShape(40,2)..." << endl; theRect.NewDrawShape(40, 2); //nem adom meg hogy true, így alapértelmetként false lesz system("pause"); return 0; }
A másoló konstruktor #include "stdafx.h" #include using namespace std; class Cat { public: Cat(); //konstruktor
90
//azért kell másoló konstruktort írni, mert a mutatókkal nem bír el a gyári konstruktor Cat(const Cat &); //másoló konstruktor deklarálása ~Cat(); //destruktor int GetAge() const { return *itsAge; } int GetWeight() const { return *itsWeight; } void SetAge(int age) { *itsAge = age; } private: int *itsAge; int *itsWeight; }; Cat::Cat() { itsAge = new int; //a dinamikus memóriaterületre mutató mutató deklarálása itsWeight = new int; *itsAge = 5; //értéket adunk a területnek *itsWeight = 9; } Cat::Cat(const Cat & rhs) //ez a másoló konstruktor { itsAge = new int; //új memória területet foglalok le itsWeight = new int; *itsAge = rhs.GetAge(); //értékül adom neki a másolandó objektum értékeit *itsWeight = rhs.GetWeight(); } Cat::~Cat() { delete itsAge; //törlöm a lefoglalt memória területet itsAge = NULL; //a mutatót nullra állítom delete itsWeight; itsWeight = NULL; } int main() { Cat frisky; cout << "frisky's age: " << frisky.GetAge() << endl; cout << "Setting frisky to 6..." << endl; frisky.SetAge(6); cout << "Creating boots from frisky..." << endl; Cat boots(frisky); //ezzel most másolatot hoztam létre //ha bármilyen más függvénynek adom át érték szerint, akkor is ezt a másoló függvényt alkalmazza cout << "frisky's age " << frisky.GetAge() << endl; cout << "boots' age: " << boots.GetAge() << endl; cout << "setting frisky to 7..." << endl; frisky.SetAge(7); //frisky életkorát megváltoztatom, de ezzel boots életkora nem fog megváltozni cout << "frisky's age " << frisky.GetAge() << endl; cout << "boots' age: " << boots.GetAge() << endl; system("pause"); return 0; }
91
Saját prefix és postfix operátorok használata #include "stdafx.h" #include using namespace std; class Counter { public: Counter(); ~Counter() { } int GetItsVal() const { return itsVal; } void SetItsVal(int x) { itsVal = x; } const Counter& operator++ (); //prefix const Counter operator++ (int); //postfix, egészet adok át neki, ezzel jelölöm hogy postfix private: int itsVal; }; Counter::Counter(): itsVal(0) //kezdőérték inicializálás { /*üres*/ } //függvénytörzs const Counter& Counter::operator++() //prefix { ++itsVal; //megnővelem a változót return *this; //visszaadom ezt az objektumot hivatkozásként } const Counter Counter::operator++(int) //postfix, az átvett egész-el nem csinálok semmit { Counter temp(*this); //másolatot képzek az objektumról ++itsVal; //megváltoztatom a változó értékét return temp; //visszaadom a másolatot, de az eredeti változása is megmarad } int main() { Counter i; cout << "The value of i is " << i.GetItsVal() << endl; i++; //meghívjuk a postfix függvényünket, ami megnőveli az i értékét cout << "The value of i is " << i.GetItsVal() << endl; ++i; //meghívjuk a prefix függvényünket, ami megnőveli az i értékét cout << "The value of i is " << i.GetItsVal() << endl; Counter a = ++i; //a prefix művelettel visszaadott objektumot, hozzá lehet rendelni az "a" objektumhoz cout << "The value of a:" << a.GetItsVal() << " and i:" << i.GetItsVal() << endl; a = i++; //a = i; i = i + 1; cout << "The value of a:" << a.GetItsVal() << " and i:" << i.GetItsVal() << endl; system("pause"); return 0; }
92
Az összeadás (+) és a különbség (-) operátor túlterhelése #include "stdafx.h" #include using namespace std; class Counter { public: Counter(); Counter(int initialValue); ~Counter() { } int GetItsVal() const { return itsVal; } void SetItsVal(int x) { itsVal = x; } //Counter Add(const Counter & rhs); //ez egy sima függvény Counter operator+ (const Counter & rhs); //ez az összeadás operátor túlterhelése Counter operator- (const Counter & rhs); //ez a különbség operátor túlterhelése private: int itsVal; }; Counter::Counter(int initialValue): itsVal(initialValue) {} Counter::Counter(): itsVal(0) {} //Counter Counter::Add(const Counter & rhs) Counter Counter::operator+ (const Counter & rhs) { return Counter(itsVal + rhs.GetItsVal()); //Counter(X); //meghívom az inicializáló konstruktort, tehát létrehozok egy helyi objektumot } Counter Counter::operator- (const Counter & rhs) { return Counter(itsVal - rhs.GetItsVal()); } int main() { Counter varOne(2), varTwo(4), varThree; //varThree = varOne.Add(varTwo); varThree = varOne + varTwo; //ez szebb megoldás mint a fenti //az előző művelet tulajdonképpen így fest: varThree = varOne.operator+(varTwo); cout << "varOne: " << varOne.GetItsVal() << endl; cout << "varTwo: " << varTwo.GetItsVal() << endl; cout << "varThree(varOne+varTwo): " << varThree.GetItsVal() << endl << endl; varThree = varOne - varTwo; cout << "varOne: " << varOne.GetItsVal() << endl; cout << "varTwo: " << varTwo.GetItsVal() << endl; cout << "varThree(varOne-varTwo): " << varThree.GetItsVal() << endl; system("pause"); return 0; }
93
A hozzárendelési (=) és az egyenlőség (==) operátor túlterhelése //új operátort nem hozhatunk létre, például ** (hatványozás) //veszélyes egyéni logikával használni a túlterhelést //az operátortúlterhelés célja a programunk stabilitásának növelése és a forráskód érthetőségének javítása //az osztályok 4 alapértelmezett függvénye: konstruktor, destruktor, másoló konstruktor, hozzárendelő konst. #include "stdafx.h" #include using namespace std; class Cat { public: Cat(); //alapértelmezett konstruktor függvényünk //a másoló konstruktort és a destruktort kihagytuk int GetAge() const { return *itsAge; } int GetWeight() const { return *itsWeight; } void SetAge(int age) { *itsAge = age; } Cat operator= (const Cat & rhs); //hozzárendelési operátor túlterhelése bool operator== (const Cat & rhs); //egyenlőség operátor túlterhelése private: int *itsAge; int *itsWeight; }; Cat::Cat() { itsAge = new int; itsWeight = new int; *itsAge = 5; *itsWeight = 9; } Cat Cat::operator= (const Cat & rhs) { if (this == &rhs) //ha önmagát akarjuk hozzárendelni return *this; delete itsAge; //töröljük a régi területet delete itsWeight; itsAge = new int; //új területet foglalunk le itsWeight = new int; *itsAge = rhs.GetAge(); //értéket adunk neki *itsWeight = rhs.GetAge(); return *this; } bool Cat::operator== (const Cat & rhs) { if (*itsAge == rhs.GetAge()) return true; else return false; } int main() { Cat Frisky; cout << "Frisky's age: " << Frisky.GetAge() << endl; cout << "Setting Frisky to 6..." << endl;
94
Frisky.SetAge(6); Cat Whisker; cout << "Frisky's age: " << Frisky.GetAge() << endl; cout << "Whisker's age: " << Whisker.GetAge() << endl; if (Frisky == Whisker) //csak az életkor, a súly nem számít cout << "Megegyezik az eletkor!" << endl; else cout << "Nem egyezik meg az eletkor!" << endl; cout << "Copying Frisky to Whisker..." << endl; Whisker = Frisky; //most ugyanannyi évesek lesznek cout << "Frisky's age: " << Frisky.GetAge() << endl; cout << "Whisker's age: " << Whisker.GetAge() << endl; if (Frisky == Whisker) //csak az életkor, a súly nem számít cout << "Megegyezik az eletkor!" << endl; else cout << "Nem egyezik meg az eletkor!" << endl; system("pause"); return 0; }
Konverziós operátor és az int() operátor //a konverziós operátoroknál nincs megadva visszatérési típus, pedig az átalakított értéket visszakapjuk #include "stdafx.h" #include using namespace std; class Counter { public: Counter(); Counter(int val); //a konverziós operátor ~Counter() { } int GetItsVal() const { return itsVal; } void SetItsVal(int x) { itsVal = x; } operator unsigned short(); //az int() operátor private: int itsVal; }; Counter::Counter(): itsVal(0) {} Counter::Counter(int val): itsVal(val) {} Counter::operator unsigned short() //nincs visszatérési típus { return (int(itsVal)); //itt adom meg a típust }
95
int main() { int theShort = 5; cout << "theShort:" << theShort; Counter theCtr = theShort; //int típust rendelünk Counterhez cout << " theCtr:" << theCtr.GetItsVal() << endl; theCtr.SetItsVal(7); theShort = theCtr; //Countert rendelünk inthez cout << "theShort:" << theShort << " theCtr:" << theCtr.GetItsVal() << endl; system("pause"); return 0; }
Objektumtömbök kezelése //olyan elemre ne hívatkozzunk, ami nincs //a tömb előkészítése: int IntegerArray[5] = { 10, 20, 30, 40, 50 }; //annyi elemet kell felsorolni, amennyi az elemszáma (mérete) #include "stdafx.h" #include using namespace std; class Cat { public: Cat() { itsAge = 1; itsWeight = 5; } //az alapértelmezett konstruktor ~Cat() { } //a destruktor int GetAge() const { return itsAge; } int GetWeight() const { return itsWeight; } void SetAge(int age) { itsAge = age; } private: int itsAge; int itsWeight; }; int main() { Cat Litter[5]; //létrehozunk egy 5 objektumból álló tömböt for (int i = 0; i < 5; i++) Litter[i].SetAge(2 * i + 1); for (int i = 0; i < 5; i++) cout << "Cat #" << i + 1 << ": " << Litter[i].GetAge() << endl; system("pause"); return 0; }
Többdimenziós tömb kezelése //myArray[sor][oszlop] //myArray[szelesseg][magassag][hosszusag] #include "stdafx.h" #include using namespace std;
96
int main() { int SomeArray[5][2] = { { 0, 0 }, { 1, 2 }, { 2, 4 }, { 3, 6 }, { 4, 8 } }; //a belső kapcsos zárójelek csak nekünk segítenek, el lehet őket hagyni //int SomeArray[5][2] = { 0, 0, 1, 2, 2, 4, 3, 6, 4, 8 }; for (int i = 0; i < 5; i++) for (int j = 0; j < 2; j++) cout << "SomeArray[" << i << "][" << j << "]: " << SomeArray[i][j] << endl; system("pause"); return 0; }
Mutatótömbök használata //tömbelemek tárolása a dinamikus memóriában //objektumok címét tároló tömböt hozok létre, ezzel a veremben lefoglalt terület méretét csökkentem #include "stdafx.h" #include using namespace std; class Cat { public: Cat() { itsAge = 1; itsWeight = 5; } ~Cat() { } int GetAge() const { return itsAge; } int GetWeight() const { return itsWeight; } void SetAge(int age) { itsAge = age; } private: int itsAge; int itsWeight; }; int main() { const unsigned short MAXSIZE = 500; //konstansként megadom a tömb méretét //500 db a dinamikus memóriában lévő objektumra mutató tömb (500 db mutató) Cat * Family[MAXSIZE]; //Cat * pCat; //1db Cat (a dinamikus memóriában) objektumra mutató for (int i = 0; i < MAXSIZE; i++) { //pCat = new Cat; //ezzel létrehozok egy objektumot //pCat->SetAge(2 * i + 1); //értéket adok neki //Family[i] = pCat; //átadom a tömbnek ezt az 1 elemet (mutatót) Family[i] = new Cat; //létrehozok egy objektumot Family[i]->SetAge(2 * i + 1); //értéket adok neki } for (int i = 0; i < MAXSIZE; i++) cout << "Cat #" << i + 1 << ": " << Family[i]->GetAge() << endl; for (int i = MAXSIZE - 1; i >= 0; i--) //for (int i = 0; i < MAXSIZE; i++) { delete Family[i]; //törlöm az objektumokat a memóriából Family[i] = NULL; } system("pause"); return 0; }
97
Tömb létrehozása a dinamikus memóriában /* Cat FamilyOne[500]; //500 db objektumot tároló tömb a veremben Cat * FamilyTwo[500]; //500 db mutató tárolása (1 db Cat objektumra mutat) Cat * FamilyThree = new Cat[500]; //1 db mutató tárolása (500 db-os Cat objektumtömbre mutat) Cat Family[50]; //példa tömb Family == &Family[0] //egyenlőek, mindkettő memória címet tartalmaz Family + 4 == &Family[5] //egyenlőek, ezek mutatók (4 * benne_tárolt_típus_mérete) *(Family + 3) == Family[4] //egyenlőek, mindkettő értéket tárol */ #include "stdafx.h" #include using namespace std; class Cat { public: Cat() { itsAge = 1; itsWeight = 5; } ~Cat(); int GetAge() const { return itsAge; } int GetWeight() const { return itsWeight; } void SetAge(int age) { itsAge = age; } private: int itsAge; int itsWeight; }; Cat::~Cat() { cout << "Destructor called!" << endl; //ebben a példában 2×10-szer fut le } int main() { Cat * Family = new Cat[10]; //10 Cat típusú elemet tároló tömb létrehozása a dinamikus memóriában /* Cat *pCat = Family; //pCat a Family[0]-ra mutat pCat->SetAge(10); //Family[0] értékét 10-re állítjuk cout << "Family[0]: " << Family[0].GetAge() << endl; pCat++; //a mutató mostmár a Family[1]-re mutat pCat->SetAge(20); //Family[1] értékét 20-ra állítjuk cout << "Family[1]: " << Family[1].GetAge() << endl; */ Cat * pCat; //létrehozok egy Cat objektumra mutatót for (int i = 0; i < 10; i++) { pCat = new Cat; //lefoglalom a területet a dinamikus memóriában pCat->SetAge(2 * i + 1); Family[i] = *pCat; //átadom az objektumot a tömbnek, másolatot képzek delete pCat; //felszabadítom a lefoglalt helyet, de a tömbben attól benne lesz } for (int i = 0; i < 10; i++) cout << "Cat #" << i + 1 << ": " << Family[i].GetAge() << endl; delete[] Family; //törlöm az egész tömböt //delete Family; //törli a tömb első elemét, memória szivárgás keletkezik system("pause"); return 0; }
98
Karaktertömbök használata #include "stdafx.h" #include using namespace std; int main() { //char Greeting[] = "Hello World"; //karaktertömb deklarálása feltöltéssel //Hello(5) + ' '(1) + World(5) + /*\0*/(1) == 12 karakter // a \0 a lezáró karakter, ez mindig kötelező char buffer[80]; //puffer, ami 80 karaktert képes tárolni cout << "Enter the string: "; //cin >> buffer; //csak szóközig olvas be cin.get(buffer, 79); //max 79. karakterig olvashat be, a lezáró karaktert a cin hozzáfüzi //a cin.get()-nek van egy bemeneti végjel paramétere is, ami alapértelmezettként az új sor cout << "Here's the buffer: " << buffer << endl; system("pause"); return 0; }
Az strcpy_s() függvény használata #include "stdafx.h" #include #include <string.h> //ez kell a függvényhez using namespace std; int main() { char String1[] = "No man is an island"; char String2[80]; //kisebb méretű tömbbe ne írjunk, mert akkor túlírjuk és hiba keletkezik strcpy_s(String2, String1); //(string copy safe) átmásolom a karaktertömb tartalmát cout << "String1: " << String1 << endl; cout << "String2: " << String2 << endl; system("pause"); return 0; }
Az strncpy_s() és strcat_s() függvény használata //az strcpy(), strncpy() és strcat() függvények így nem müködtek, csak _s alakban #include "stdafx.h" #include #include <string.h> //ez kell a függvényhez using namespace std; int main() { const int MaxLength = 80; char String1[] = "No man is an island"; char String2[MaxLength + 1]; cout << "String1 length: " << strlen(String1) << endl; strncpy_s(String2, String1, MaxLength); //(string number copy safe) //átmásolja a tartalmat a lezáró karakterig vagy a maximálisan megadott karakterig String2[strlen(String1)] = '\0'; //a végére elhelyezem a lezáró karaktert cout << "String1: " << String1 << endl; cout << "String2: " << String2 << endl;
99
strcat_s(String2, String1); //két karaktertömb összefüzése cout << "String1 + String2: " << String2 << endl; system("pause"); return 0; }
WinForm-os ablak 1. //.cpp fájl tartalma #include "stdafx.h" //visual studiohoz #include "Form1.h" //ez a Formom fejlécállománya using namespace WinFormAlkalmazas; //ez a .cpp fájl neve [STAThreadAttribute] //ez nem tudom mi int main(array<System::String ^> ^args) //nem tudom milyen paraméterek ezek { Application::EnableVisualStyles(); //Windows XP vizuális effektek engedélyezése Application::SetCompatibleTextRenderingDefault(false); //az ellenőrzések megkezdése előtt Application::Run(gcnew Form1()); //létrehozom a Főablakot és futtatom return 0; }
//.h fájl tartalma #pragma once namespace WinFormAlkalmazas //itt a .cpp fájl nevét adom meg { using namespace System; using namespace System::ComponentModel; using namespace System::Collections; using namespace System::Windows::Forms; using namespace System::Data; using namespace System::Drawing; ///<summary> ///összegzés a Form-ról /// public ref class Form1 : public System::Windows::Forms::Form //a saját form osztályom kezdete { public: Form1(void) //konstruktor { InitializeComponent(); //meghívom a tagfüggvényét //itt adhatom meg a konstruktor kódot } protected: ///<summary> ///felszabadítja a használt erőforrásokat /// ~Form1() //destruktor { if (components) { delete components; } }
100
private: ///<summary> ///igényelt tervezői változók /// System::ComponentModel::Container ^components; System::Windows::Forms::Label^ felir; //a Label deklarálása System::Windows::Forms::Button^ kilep; //Kilépés gomb deklarálása #pragma region Windows Form Designer generated code ///<summary> ///szükséges metódusok a tervező támogatásához – nem változtatja ennek a kódszerkesztőnek a tartalmát /// void InitializeComponent(void) //komponensek inicializálása (tagfüggvény) { this->felir = (gcnew System::Windows::Forms::Label()); this->kilep = (gcnew System::Windows::Forms::Button()); this->SuspendLayout(); this->felir->Name = "felir"; //név (azonosító) this->felir->AutoSize = true; //automatikus méretezés this->felir->Text = "Ez egy WinForm-os ablak!"; //felírat, tartalom this->felir->Size = System::Drawing::Size(130, 13); //méret this->felir->Location = System::Drawing::Point(74, 50); //koordináta this->felir->TabIndex = 0; //TAB sorrend this->kilep->Name = "kilep"; //név (azonosító) this->kilep->UseVisualStyleBackColor = true; //nem tudom hogy ez mi this->kilep->Text = "Kilépés"; //felírat, tartalom this->kilep->Size = System::Drawing::Size(75, 23); //méret this->kilep->Location = System::Drawing::Point(184, 227); //koordináta this->kilep->TabIndex = 1; //TAB sorrend this->kilep->Click += gcnew System::EventHandler(this, &Form1::kilep_Click); //rákkatintás //a Form tulajdonságainak beállítása this->Name = "Form1"; //név (azonosító) this->AutoScaleMode = System::Windows::Forms::AutoScaleMode::Font; this->ResumeLayout(false); this->PerformLayout(); this->Text = "WinForm-os"; //felírat, tartalom this->AutoScaleDimensions = System::Drawing::SizeF(6, 13); //talán a fejlécméret this->ClientSize = System::Drawing::Size(284, 262); //méret this->Controls->Add(this->kilep); //hozzárendelem a Kilépés gombot this->Controls->Add(this->felir); //hozzárendelem a felíratot } #pragma endregion private: System::Void kilep_Click(System::Object^ sender, System::EventArgs^ e) { Application::Exit(); //így tudok kilépni az alkalmazásból } }; }
WinForm-os ablak 2. //.cpp fájl tartalma #include "stdafx.h" #include "Form1.h" using namespace WinFormAlk;
101
int main() { Application::Run(gcnew Form1()); return 0; }
//.h fájl tartalma #pragma once namespace WinFormAlk { using namespace System; using namespace System::Windows::Forms; using namespace System::Drawing;
public ref class Form1 : public System::Windows::Forms::Form { public: Form1(void) { InitializeComponent(); } protected: ~Form1() { if (components) { delete components; } } private: System::Windows::Forms::Button^ kilep; private: System::Windows::Forms::Label^ felir; protected: private: System::ComponentModel::Container ^components; #pragma region Windows Form Designer generated code void InitializeComponent(void) { this->kilep = (gcnew System::Windows::Forms::Button()); this->felir = (gcnew System::Windows::Forms::Label()); this->kilep->Name = "kilep"; this->kilep->Text = "Kilépés"; this->kilep->Size = System::Drawing::Size(110, 50); this->kilep->UseVisualStyleBackColor = false; this->kilep->BackColor = System::Drawing::Color::Gainsboro; this->kilep->Font = (gcnew Drawing::Font("Arial", 20, FontStyle::Regular, GraphicsUnit::Point, static_cast(238))); this->kilep->Click += gcnew System::EventHandler(this, &Form1::kilep_Click); this->felir->Name = "felir"; this->felir->Text = "Ez egy WinForm-os ablak!"; this->felir->Font = (gcnew Drawing::Font("Arial", 30, FontStyle::Regular, GraphicsUnit::Point, static_cast(238))); this->felir->ForeColor = System::Drawing::Color::Blue; this->felir->AutoSize = true; this->felir->Cursor = System::Windows::Forms::Cursors::No;
102
this->Name = "Form1"; this->Text = "WinForm-os"; //felírat(név) this->Size = System::Drawing::Size(500, 300); //szélesség, magasság this->BackColor = System::Drawing::Color::Silver; //háttérszín módosítása this->Controls->Add(this->felir); this->Controls->Add(this->kilep); this->Load += gcnew System::EventHandler(this, &Form1::Form1_Load); } #pragma endregion private: System::Void Form1_Load(System::Object^ sender, System::EventArgs^ e) { //most beállítom középre az ablakot, ahhoz lekérem a képernyő méretét System::Drawing::Rectangle kepernyoMeret = Screen::PrimaryScreen->WorkingArea; int X = (kepernyoMeret.Width - Size.Width) / 2; //kiszámolom az ablakom koordinátáit int Y = (kepernyoMeret.Height - Size.Height) / 2; Location = System::Drawing::Point(X, Y); //elhelyezem a megadott koordinátákra X = Size.Width - kilep->Size.Width - 16 - 10; //16-ot csal a program Y = Size.Height - kilep->Size.Height - 38 - 10; //38-at csal a program kilep->Location = System::Drawing::Point(X, Y); X = 5; Y = (Size.Height - felir->Size.Height) / 2 - 20; //kb. 20-at csal a program this->felir->Location = System::Drawing::Point(X, Y); } private: System::Void kilep_Click(System::Object^ sender, System::EventArgs^ e) { Application::Exit(); } }; }
Események használata és kezelése //.cpp fájl tartalma #include "stdafx.h" #include "Form1.h" using namespace MyProdzsekt; int main() { Application::Run(gcnew Form1()); return 0; }
//.h fájl tartalma #pragma once namespace MyProdzsekt { using namespace System; using namespace System::Windows::Forms; using namespace System::Drawing; public ref class Form1 : public System::Windows::Forms::Form { public: Form1(void) { InitializeComponent(); }
103
protected: ~Form1() { if (components) { delete components; } } private: System::Windows::Forms::TextBox^ txtTextControl; System::Windows::Forms::Label^ lblMessage; System::Windows::Forms::Button^ btnExit; System::Windows::Forms::Label^ lblHeader1; System::Windows::Forms::Label^ lblHeader2; // System::ComponentModel::Container ^components; #pragma region Windows Form Designer generated code void InitializeComponent(void) { this->txtTextControl = (gcnew System::Windows::Forms::TextBox()); this->lblMessage = (gcnew System::Windows::Forms::Label()); this->btnExit = (gcnew System::Windows::Forms::Button()); this->lblHeader1 = (gcnew System::Windows::Forms::Label()); this->lblHeader2 = (gcnew System::Windows::Forms::Label()); this->txtTextControl->Name = "txtTextControl"; this->txtTextControl->Size = System::Drawing::Size(100, 20); this->txtTextControl->Location = System::Drawing::Point(31, 119); this->txtTextControl->TabIndex = 0; this->txtTextControl->Click += gcnew System::EventHandler(this, &Form1::txtTextControl_Click); this->txtTextControl->TextChanged += gcnew System::EventHandler(this, &Form1::txtTextControl_TextChanged); this->txtTextControl->DoubleClick += gcnew System::EventHandler(this, &Form1::txtTextControl_DoubleClick); this->txtTextControl->MouseEnter += gcnew System::EventHandler(this, &Form1::txtTextControl_MouseEnter); this->txtTextControl->MouseLeave += gcnew System::EventHandler(this, &Form1::txtTextControl_MouseLeave); this->lblMessage->Name = "lblMessage"; this->lblMessage->AutoSize = false; //automatikus méretezés kikapcsolása this->lblMessage->Size = System::Drawing::Size(100, 23); this->lblMessage->BorderStyle = System::Windows::Forms::BorderStyle::Fixed3D; //3D-s keret this->lblMessage->Location = System::Drawing::Point(31, 53); this->lblMessage->TabIndex = 1; this->btnExit->Name = "btnExit"; this->btnExit->Text = "E&xit"; //a & azt eredményezi, hogy az x alálesz húzva this->btnExit->UseVisualStyleBackColor = true; //a gomb háttérszíne olyan mint a form színe this->btnExit->Size = System::Drawing::Size(75, 23); this->btnExit->Location = System::Drawing::Point(43, 159); this->btnExit->TabIndex = 2; this->btnExit->Click += gcnew System::EventHandler(this, &Form1::btnExit_Click); this->lblHeader1->Name = "lblHeader1"; this->lblHeader1->Text = "Event Triggered"; this->lblHeader1->AutoSize = true; this->lblHeader1->Size = System::Drawing::Size(83, 13); this->lblHeader1->Location = System::Drawing::Point(40, 30); this->lblHeader1->TabIndex = 3;
104
this->lblHeader2->Name = "lblHeader2"; this->lblHeader2->Text = "Test Control"; this->lblHeader2->AutoSize = true; this->lblHeader2->Size = System::Drawing::Size(64, 13); this->lblHeader2->Location = System::Drawing::Point(49, 96); this->lblHeader2->TabIndex = 4; this->Name = "Form1"; this->Text = "Events"; this->AutoScaleDimensions = System::Drawing::SizeF(6, 13); this->AutoScaleMode = System::Windows::Forms::AutoScaleMode::Font; this->ClientSize = System::Drawing::Size(160, 212); this->Controls->Add(this->txtTextControl); this->Controls->Add(this->lblHeader2); this->Controls->Add(this->lblMessage); this->Controls->Add(this->btnExit); this->Controls->Add(this->lblHeader1); this->ResumeLayout(false); this->PerformLayout(); } #pragma endregion private: System::Void btnExit_Click(System::Object^ sender, System::EventArgs^ e) { Application::Exit(); } private: System::Void txtTextControl_Click(System::Object^ sender, System::EventArgs^ e) { lblMessage->Text = "Click"; } private: System::Void txtTextControl_DoubleClick(System::Object^ sender, System::EventArgs^ e) { lblMessage->Text = "Double Click"; } private: System::Void txtTextControl_MouseEnter(System::Object^ sender, System::EventArgs^ e) { lblMessage->Text = "Mouse Enter"; } private: System::Void txtTextControl_MouseLeave(System::Object^ sender, System::EventArgs^ e) { lblMessage->Text = "Mouse Leave"; } private: System::Void txtTextControl_TextChanged(System::Object^ sender, System::EventArgs^ e) { lblMessage->Text = "Text Changed"; } }; }
Változók és hibakeresés //.cpp fájl tartalma #include "stdafx.h" #include "Form1.h" using namespace MyProdzsekt; int main() { Application::Run(gcnew Form1()); return 0; }
//.h fájl tartalma #pragma once namespace MyProdzsekt
105
{ using namespace System; using namespace System::Windows::Forms; using namespace System::Drawing; public ref class Form1 : public System::Windows::Forms::Form { public: Form1(void) { InitializeComponent(); } protected: ~Form1() { if (components) { delete components; } } private: System::Windows::Forms::Label^ lblHeader1; System::Windows::Forms::Label^ lblHeader2; System::Windows::Forms::Label^ lblEquals; System::Windows::Forms::Label^ lblHeader3; System::Windows::Forms::TextBox^ txtFeet; System::Windows::Forms::TextBox^ txtInches; System::Windows::Forms::TextBox^ txtConvertedInches; System::Windows::Forms::Button^ btnConvert; System::Windows::Forms::Button^ btnExit; System::ComponentModel::Container ^components; //saját változóim int iInches; int iFeet; int iConvertedInches; #pragma region Windows Form Designer generated code void InitializeComponent(void) { this->lblHeader1 = (gcnew System::Windows::Forms::Label()); this->lblHeader2 = (gcnew System::Windows::Forms::Label()); this->lblEquals = (gcnew System::Windows::Forms::Label()); this->lblHeader3 = (gcnew System::Windows::Forms::Label()); this->txtFeet = (gcnew System::Windows::Forms::TextBox()); this->txtInches = (gcnew System::Windows::Forms::TextBox()); this->txtConvertedInches = (gcnew System::Windows::Forms::TextBox()); this->btnConvert = (gcnew System::Windows::Forms::Button()); this->btnExit = (gcnew System::Windows::Forms::Button()); this->lblHeader1->Name = "lblHeader1"; this->lblHeader1->Text = "Feet"; this->lblHeader1->AutoSize = true; this->lblHeader1->Size = System::Drawing::Size(28, 13); this->lblHeader1->Location = System::Drawing::Point(13, 13); this->lblHeader1->TabIndex = 0; this->lblHeader2->Name = "lblHeader2"; this->lblHeader2->Text = "Inches"; this->lblHeader2->AutoSize = true; this->lblHeader2->Size = System::Drawing::Size(39, 13); this->lblHeader2->Location = System::Drawing::Point(83, 13); this->lblHeader2->TabIndex = 1;
106
this->lblEquals->Name = "lblEquals"; this->lblEquals->Text = "="; this->lblEquals->AutoSize = true; this->lblEquals->Size = System::Drawing::Size(13, 13); this->lblEquals->Location = System::Drawing::Point(150, 40); this->lblEquals->TabIndex = 2; this->lblHeader3->Name = "lblHeader3"; this->lblHeader3->Text = "Inches"; this->lblHeader3->AutoSize = true; this->lblHeader3->Size = System::Drawing::Size(39, 13); this->lblHeader3->Location = System::Drawing::Point(175, 13); this->lblHeader3->TabIndex = 3; this->txtFeet->Name = "txtFeet"; this->txtFeet->Size = System::Drawing::Size(42, 20); this->txtFeet->Location = System::Drawing::Point(13, 40); this->txtFeet->TabIndex = 4; this->txtFeet->TextChanged += gcnew System::EventHandler(this, &Form1::txtFeet_TextChanged); this->txtInches->Name = "txtInches"; this->txtInches->Size = System::Drawing::Size(54, 20); this->txtInches->TabIndex = 5; this->txtInches->Location = System::Drawing::Point(83, 40); this->txtInches->TextChanged += gcnew System::EventHandler(this, &Form1::txtInches_TextChanged); this->txtConvertedInches->Name = "txtConvertedInches"; this->txtConvertedInches->Size = System::Drawing::Size(52, 20); this->txtConvertedInches->Location = System::Drawing::Point(175, 40); this->txtConvertedInches->Enabled = false; //ne legyen használható this->txtConvertedInches->TabIndex = 6; this->btnConvert->Name = "btnConvert"; this->btnConvert->Text = "&Convert"; this->btnConvert->UseVisualStyleBackColor = true; this->btnConvert->Size = System::Drawing::Size(75, 23); this->btnConvert->Location = System::Drawing::Point(35, 80); this->btnConvert->TabIndex = 7; this->btnConvert->Click += gcnew System::EventHandler(this, &Form1::btnConvert_Click); this->btnExit->Name = "btnExit"; this->btnExit->Text = "E&xit"; this->btnExit->UseVisualStyleBackColor = true; this->btnExit->Size = System::Drawing::Size(75, 23); this->btnExit->Location = System::Drawing::Point(130, 80); this->btnExit->TabIndex = 8; this->btnExit->Click += gcnew System::EventHandler(this, &Form1::btnExit_Click); this->Name = "Form1"; this->Text = "Variables and Debugging"; this->AutoScaleDimensions = System::Drawing::SizeF(6, 13); this->AutoScaleMode = System::Windows::Forms::AutoScaleMode::Font; this->ClientSize = System::Drawing::Size(240, 120); this->Controls->Add(this->btnExit); this->Controls->Add(this->btnConvert); this->Controls->Add(this->txtConvertedInches); this->Controls->Add(this->txtInches); this->Controls->Add(this->txtFeet); this->Controls->Add(this->lblHeader3); this->Controls->Add(this->lblEquals); this->Controls->Add(this->lblHeader2); this->Controls->Add(this->lblHeader1);
107
this->ResumeLayout(false); this->PerformLayout(); } #pragma endregion private: System::Void btnExit_Click(System::Object^ sender, System::EventArgs^ e) { Application::Exit(); } private: System::Void txtFeet_TextChanged(System::Object^ sender, System::EventArgs^ e) { int iTemp; if(Int32::TryParse(txtFeet->Text, iTemp)) //konvertálók hibakeresést végző függvénnyel iFeet = Convert::ToInt32(txtFeet->Text); //ha nincs hiba else txtFeet->Text = Convert::ToString(iFeet); //ha hiba van } private: System::Void txtInches_TextChanged(System::Object^ sender, System::EventArgs^ e) { int iTemp; if(Int32::TryParse(txtInches->Text, iTemp)) iInches = Convert::ToInt32(txtInches->Text); else txtInches->Text = Convert::ToString(iInches); } private: System::Void btnConvert_Click(System::Object^ sender, System::EventArgs^ e) { iConvertedInches = (iFeet * 12) + iInches; //elvégzem az átváltást txtConvertedInches->Text = Convert::ToString(iConvertedInches); //kiírom az eredményt } }; }
Függvények készítése //.cpp fájl tartalma #include "stdafx.h" #include "Form1.h" using namespace MyProdzsekt; int main() { Application::Run(gcnew Form1()); return 0; }
//.h fájl tartalma #pragma once namespace MyProdzsekt { using namespace System; using namespace System::Windows::Forms; using namespace System::Drawing; public ref class Form1 : public System::Windows::Forms::Form { public: Form1(void) { InitializeComponent(); } protected: ~Form1() { if (components)
108
{ delete components; } } private: System::Windows::Forms::Label^ lblHeader1; System::Windows::Forms::Label^ lblHeader2; System::Windows::Forms::Label^ lblEquals; System::Windows::Forms::Label^ lblHeader3; System::Windows::Forms::TextBox^ txtFeet; System::Windows::Forms::TextBox^ txtInches; System::Windows::Forms::TextBox^ txtConvertedInches; System::Windows::Forms::Button^ btnConvert; System::Windows::Forms::Button^ btnExit; System::ComponentModel::Container ^components; //saját változóim int iInches; int iFeet; int iConvertedInches; #pragma region Windows Form Designer generated code void InitializeComponent(void) { this->lblHeader1 = (gcnew System::Windows::Forms::Label()); this->lblHeader2 = (gcnew System::Windows::Forms::Label()); this->lblEquals = (gcnew System::Windows::Forms::Label()); this->lblHeader3 = (gcnew System::Windows::Forms::Label()); this->txtFeet = (gcnew System::Windows::Forms::TextBox()); this->txtInches = (gcnew System::Windows::Forms::TextBox()); this->txtConvertedInches = (gcnew System::Windows::Forms::TextBox()); this->btnConvert = (gcnew System::Windows::Forms::Button()); this->btnExit = (gcnew System::Windows::Forms::Button()); this->lblHeader1->Name = "lblHeader1"; this->lblHeader1->Text = "Feet"; this->lblHeader1->AutoSize = true; this->lblHeader1->Size = System::Drawing::Size(28, 13); this->lblHeader1->Location = System::Drawing::Point(13, 13); this->lblHeader1->TabIndex = 0; this->lblHeader2->Name = "lblHeader2"; this->lblHeader2->Text = "Inches"; this->lblHeader2->AutoSize = true; this->lblHeader2->Size = System::Drawing::Size(39, 13); this->lblHeader2->Location = System::Drawing::Point(83, 13); this->lblHeader2->TabIndex = 1; this->lblEquals->Name = "lblEquals"; this->lblEquals->Text = "="; this->lblEquals->AutoSize = true; this->lblEquals->Size = System::Drawing::Size(13, 13); this->lblEquals->Location = System::Drawing::Point(150, 40); this->lblEquals->TabIndex = 2; this->lblHeader3->Name = "lblHeader3"; this->lblHeader3->Text = "Inches"; this->lblHeader3->AutoSize = true; this->lblHeader3->Size = System::Drawing::Size(39, 13); this->lblHeader3->Location = System::Drawing::Point(175, 13); this->lblHeader3->TabIndex = 3;
109
this->txtFeet->Name = "txtFeet"; this->txtFeet->Size = System::Drawing::Size(42, 20); this->txtFeet->Location = System::Drawing::Point(13, 40); this->txtFeet->TabIndex = 4; this->txtFeet->TextChanged += gcnew System::EventHandler(this, &Form1::txtFeet_TextChanged); this->txtInches->Name = "txtInches"; this->txtInches->Size = System::Drawing::Size(54, 20); this->txtInches->TabIndex = 5; this->txtInches->Location = System::Drawing::Point(83, 40); this->txtInches->TextChanged += gcnew System::EventHandler(this, &Form1::txtInches_TextChanged); this->txtConvertedInches->Name = "txtConvertedInches"; this->txtConvertedInches->Size = System::Drawing::Size(52, 20); this->txtConvertedInches->Location = System::Drawing::Point(175, 40); this->txtConvertedInches->Enabled = false; //ne legyen használható this->txtConvertedInches->TabIndex = 6; this->btnConvert->Name = "btnConvert"; this->btnConvert->Text = "&Convert"; this->btnConvert->UseVisualStyleBackColor = true; this->btnConvert->Size = System::Drawing::Size(75, 23); this->btnConvert->Location = System::Drawing::Point(35, 80); this->btnConvert->TabIndex = 7; this->btnConvert->Click += gcnew System::EventHandler(this, &Form1::btnConvert_Click); this->btnExit->Name = "btnExit"; this->btnExit->Text = "E&xit"; this->btnExit->UseVisualStyleBackColor = true; this->btnExit->Size = System::Drawing::Size(75, 23); this->btnExit->Location = System::Drawing::Point(130, 80); this->btnExit->TabIndex = 8; this->btnExit->Click += gcnew System::EventHandler(this, &Form1::btnExit_Click); this->Name = "Form1"; this->Text = "Variables and Debugging"; this->AutoScaleDimensions = System::Drawing::SizeF(6, 13); this->AutoScaleMode = System::Windows::Forms::AutoScaleMode::Font; this->ClientSize = System::Drawing::Size(240, 120); this->Controls->Add(this->btnExit); this->Controls->Add(this->btnConvert); this->Controls->Add(this->txtConvertedInches); this->Controls->Add(this->txtInches); this->Controls->Add(this->txtFeet); this->Controls->Add(this->lblHeader3); this->Controls->Add(this->lblEquals); this->Controls->Add(this->lblHeader2); this->Controls->Add(this->lblHeader1); this->ResumeLayout(false); this->PerformLayout(); } #pragma endregion private: System::Void btnExit_Click(System::Object^ sender, System::EventArgs^ e) { Application::Exit(); } private: System::Void txtFeet_TextChanged(System::Object^ sender, System::EventArgs^ e) { int iRetVal; iRetVal = ValidateKeyPress(txtFeet->Text); if (iRetVal >= 0) //így a -1 nincs benne, tehát az hamis iFeet = iRetVal;
110
else { txtFeet->Text = Convert::ToString(iFeet); //ha rossz érték txtFeet->SelectAll(); //kijelöli a TextBox tartalmát } } private: System::Void txtInches_TextChanged(System::Object^ sender, System::EventArgs^ e) { int iRetVal; iRetVal = ValidateKeyPress(txtInches->Text); if (iRetVal >= 0) //így a -1 nincs benne, tehát az hamis iInches = iRetVal; else { txtInches->Text = Convert::ToString(iInches); //ha rossz érték txtInches->SelectAll(); //kijelöli a TextBox tartalmát } } private: System::Void btnConvert_Click(System::Object^ sender, System::EventArgs^ e) { System::String^ sConvertedVal; //így deklarálok egy stringet iConvertedInches = CalculateInches(iFeet, iInches); //kiszámolom a saját függvénnyemmel sConvertedVal = Convert::ToString(iConvertedInches); //konvertálás (integer to string) txtConvertedInches->Text = sConvertedVal; } private: int CalculateInches(int iFeetIn, int iInchesIn) { //ez egy saját függvény return (iFeetIn * 12 + iInchesIn); //elvégzem a műveletet és visszaadom az értéket } private: int ValidateKeyPress(System::String^ sControlText) { int iTest; if (Int32::TryParse(sControlText, iTest)) return iTest; else { MessageBox::Show("You typed an invalid value!", "ERROR!!!"); //üzenetdoboz return -1; //-1 csak akkor lehet ha hiba van } } }; }
RadioButton include
111
