1 Rev 4. A C++ programozás alapjai- segédlet

Méret: px
Mutatás kezdődik a ... oldaltól:

Download "1 Rev 4. A C++ programozás alapjai- segédlet"

Átírás

1 1 A C++ programozás alapjai- segédlet

2 Tartalomjegyzék 1 Bevezetés POSIX specifikáció Fordítók és fejlesztői környezetek GNU-LINUX GCC Windows Cygwin Windows: MinGW Az Eclipse IDE Telepítés Windows alatt Az Eclipse használatának alapjai Egy egyszerű példa Hello World forrás Megjegyzések, kommentek Egyszerű input / output Elemi adattipusok Adattípusok, változók, és jellemzőik Beépített alaptípusok Egész számok Lebegőpontos számok Karakterek Logikai típus Stringek Típuskonverzió Változó nevek Szimbolikus konstansok Példák Kifejezések Aritmetikai operátorok Relációs operátorok Logikai operátorok Bitenkénti operátorok Auto inkrement - auto dekrement Értékadó operátorok Feltételes operátorok Vessző operátor sizeof operátor Pointerek Bővebben az elemi stringekről Precedencia Utasítások, vezérlési szerkezetek Utasítások Egyszerű feltételvizsgálat Egymásba ágyazott, többszintű feltételvizsgálat Elágazásos feltételvizsgálat Ciklusszervezés while utasítással Ciklusszervezés do-while utasítással Ciklusszervezés for utasítással

3 3.8 Ciklusszervezés tartományra for utasítással A continue utasítás A break utasítás A goto utasítás A return utasítás Függvények A függvények részei: Függvény deklaráció Függvény paraméterek és argumentumok Hatókör Argumentumok alapértelmezett értéke Parancssori argumentumok Függvények túlterhelése Függvény pointerek Összetett adattípusok Tömbök Struktúrák Az osztályokról általában Tagfüggvények, vagy metódusok Adattagok, vagy tagváltozók Hozzáférési engedélyek Konstruktorok Destruktorok Osztálytagok - osztályváltozók A this változó Inicializációs lista Operátor túlterhelés Öröklődés (származtatás, bővítés) Barátosztályok (friendship) Többszörös öröklődés Polimorfizmus Absztrakt osztály: Osztály template-ek Implicit típuskonverzió inline Függvények További ismeretek az adattipusokról Union-ok Enumeráció A fájlkezelés alapjai Típusdefiníció Dinamikus memória kezelés Tárolási osztályok és típusminősítők Egyéb osztálytulajdonságok Bináris operátor túlterhelésről részletesen Konstans objektumváltozók Konstans osztályváltozók Statikus tagfüggvények Tagobjektumok Objektum tömbök

4 9.7 Osztály láthatóság Egyéb, fontosabb osztályok String osztály Preprocesszor Lépései: Direktívák:

5 1 Bevezetés 5

6 1.1 POSIX specifikáció Portable Operating System Interface olyan specifikáció, amely leírja egy általános Unix szerű operációs rendszer paramétereit. Alapvetően két témakörből áll: 1. POSIX Alapdefiníciók: System interfészek és parancsok Real-time szolgáltatások Thread szolgáltatások Biztonsági interfészek Hálózatkezelés Védelmi és vezérlő parancsok Batch kezelő programok 2. POSIX megfelelőségi tesztek 6

7 1.2 Fordítók és fejlesztői környezetek 7

8 1.2.1 GNU-LINUX GCC Debian / Ubuntu disztribúciók esetén: cli:sudo apt-get install gcc g++ synaptic package manager software centre Windows Cygwin Eredeti fejlesztője a Cygnus Solutions. Feladata: Teljes POSIX réteg megvalósítása könyvtárak és rendszerhívások emulálására. Ennél a megoldásnál a POSIX réteg folyamatosan fut a Windows-ban, ami többlet CPU kapacitást igényel. A Cygwin segítségével lefordított programokhoz a kompatibilitási réteget biztosító lib-et is mellékelni célszerű, hogy futtathatók legyenek. Felépítése: Library, ami a Unix (POSIX) rendszerhívásokat Win32-nek megfelelő rendszerhívásokat (API) valósítja meg GNU development toolchain nagy számú, Unix-ra jellemző parancsot megvalósító alkalmazás (mount, sshd, Apache, grep, emacs, vi, sed, stb) Windows: MinGW Minimalist GNU for Windows - a Cygwin első változatából ágazott le. A kompatibilitást direkt WIndows hívásokra fordítja le. Nem biztosít teljes POSIX kompatibilitást, a teljes Unix programkínálat nem fordítható le a segítségével. Erőforrás igénye kisebb, nem igényli a kompatibilitási réteg folyamatos jelenlétét Az Eclipse IDE Eredeti fejlesző: IBM Canada Kezelője 2004 óta az Eclipse Foundation. Java alapú fejlesztő környezet. Licence: EPL (Eclipse Public Licence) - FSF szerint free licence, de nem GPL kompatibilis. Felépítés: Workspace Plugin rendszer Az Eclipse IDE 8

9 1.2.5 Telepítés Windows alatt 1. Java runtime install Download download html 2. MinGW (Minimal GCC for Windows) letöltés Downloads Installer: mingw32-base mingw32-gcc-g++ PATH_ba beírni a MINGW/bin-t: 1. file explorer-ben ráálni a c:mingw/bin-re, jobb gomb és copy 2. control panel: system and security -> system ->advanced fül, és environment variable. 3. PATH után beírni ; után a bemásolt útvonalat! 3. Eclipse CDT letöltés Átnevezés a hosszú filenév elkerülése miatt eclipse.zip-re Eclipse indítás. New project -> C++ -> Hello world Project properties -> c/c++ build -> Tool Chain Editor-ban MINGW-t beállítani Cross GCC helyett Ha internal build helyett make-re állítjuk, a Project Properties -> C/C++ Build-ben a make-et migw32-make -re kell módosítani Az Eclipse használatának alapjai 9

10 1.3 Egy egyszerű példa Hello World forrás #include <iostream> // preprocesszor direktíva int main(void) // főprogram, függvény neve // utasításblokk kezdete std::cout << "Hello World\n"; //kiíratás // utasításblokk vége #include - preprocesszor direktíva A fordítás előtt bevágja a megadott fájlt mint szövegállományt a forrásba. Az iostream.h egy u.n. header fájl, amely az iostream-mel kapcsolatos deklarációkat és definíciókat tartalmazza. Régebbi környezetekben iostream.h, újabban iostream. int main() - a program legmagasabb szintű végrehajtandó függvénye A függvényeknek lehet 0, vagy több paramétere. A void azt jelöli, hogy nincs paraméter. Jelen esetben a függvény visszatérő értékének típusa integer. Minden C++ programnak egy, és csak egy main() függvénye van. A programvégrehajtás a main()-en kezdődik. 10

11 - a függvény testének a kezdete (utasításblokk kezdete) A következő sor a main()-t alkotó utasítások sora. Minden utasítást ;-vel kell lezárni. "Hello World\n" string kiíratása a cout output stream-re. \n - újsor karakter jelölése. std:: - Standard IO névtere. cout - Standard output stream. << - túltelített operátor. Balértékként az output stream-et, jobbértékként egy kifejezéstkell megadni. - A függvény testének a vége (utasításblokk vége) A kiterjesztés a UNIX szerű környezetben.cc, Windows környezetben cpp. (Helloworld.cc vagy Helloworld.cpp) Fordítás: g++ HelloWorld.cc A kimenő fájl jelen esetben a.out, de a -o fordítási opcióval tetszőleges kimenő fájlnév megadható Megjegyzések, kommentek // általában tört soros megjegyzés /* általában hosszabb, akár több soros megjegyzés */ Alapvető szabályok: A megjegyzések nem egymásba ágyazhatóak. A megjegyzés legyen érthetőbb, mint a programrészlet, amit leír! Túl sok megjegyzés csökkenti a program olvashatóságát. Beszélő szimbólumok használata csökkenti a megjegyzések számát. A megjegyzéseket általában angolul írjuk! "Mérőszám: WTF/minute" Egyszerű input / output Operátorok: << kiírás stream-be >> beolvasás stream-ből A stream-ek az <iostream.h> vagy az <iostream> include fájlok segítségével érhetők el. cout kiviteli stream cin beviteli stream Példa: Workhours3.cpp 11

12 1.3.4 Fordítási lépések 1.4 Elemi adattipusok Adattípusok, változók, és jellemzőik A változók adatok átmeneti tárolására szolgálnak. A fordító a RAM-ban foglalt memóriatartományban helyezi el őket. Ez természetesen nem áll a const előtagú szimbólumokra. (Lásd később.) A változókat két attríbútummal jellemezzük. Típus - a változó definiálásakor adandó meg, a továbbiakban nem lehet megváltoztatni. Érték - tetszőleges időpontban újraírható. Definíció és értékadás A változó első értékadása az inicializálás. A példában a definíció és az értékadás elkülönül, de inicializáláskor ez együttesen is elvégezhető. Inicializálás nélkül elvileg lehetséges használni a változókat, de ilyenkor az értékük véletlenszerű. Értékadás Ennek során a válozóhoz konkrét értéket rendelünk. a = 3; int a (3); int a 3; // -std=c++11 vagy -std=gnu

13 Beépített alaptípusok Alaptípusok int egész float lebegőpontos double dupla pontosságú lebegőpontos bool logikai char karakter wchar_t széles karakter void típus nélküli Módosítók: signed előjeles unsigned előjeltelen short rövid tárolási mód long hosszú tárolási mód 13

14 Egész számok Típusok: (Alapértelmezés: signed) short int vagy short 2byte int legalább annyi, vagy több byte, mint a short 4byte long int vagy long legalább annyi, vagy több byte, mint az int 4byte long long 8byte unsigned... signed... Literalok: Számérték valamilyen számrendszerben kifejezett alakja. 19 int (alapértelmezés) 19L long 19LL long long 19U unsigned 19LU long unsigned... 14

15 Lebegőpontos számok Típusok: (Alapértelmezés: signed) float 4byte double legalább annyi, vagy több byte, mint a float 8byte long double legalább annyi, vagy több byte, mint a double 8 vagy 10 byte Literalok: 0.06F- float szimpla pontosság 0.06 double dupla pontosság 0.06L long long double 2.132E-3 exponenciális alak Számrendszerek ábrázolása 45 decimális 045 oktális 0X45 hexa 15

16 Karakterek A karakter kódja - numerikus érték, a kódrendszertől függ. Legelterjedtebb: ASCII. Pl 'A' = 65, 'a' = 97 Alapértelmezett a signed, de lehet unsigned is. Típusok: (Alapértelmezés: signed) char 1byte wchar_t 2 vagy 4 byte Előfordulhatnak még: char8_t char16_t char32_t uchar Példák: signed char letter = 'A'; unsigned char row = 2, column = 4; Literalok: 'A' '\r' - carriage return '\n' - new line '\t' - vízszintes tabulator '\v' - függőleges tabulator '\b' - backspace '\f' - formfeed '\\' - backslash '\'' - aposztróf '\"' - idézőjel '\ooo' - oktális számmal ábrázolt ascii kód '\0' - null kódú karakter '\a' - alert '\?' - kérdőjel 16

17 Logikai típus Valójában int-tel egyenértékű típus. Értéke 0, vagy nem 0, de a jobb olvashatóság érdekében használható helyette a vele egyenértékű bool. Típusok: bool - 1 byte Literalok: true false 17

18 Stringek A string változó értéke az a memória cím, ahol a string kezdődik. A stringet mindig \0 karakter zárja le: H E L L O \0 Típusok: (Alapértelmezés: signed) char* A hossz tetszőleges. Literalok: "Hello World\n" "Name\tAddress\tPhone" Több soros literal: "This is an example \ of a multi line literal" Figyelem! "A" nem azonos 'A'-val! "" valójában egy \0, de a típusa nem azonos a karakter típussal. 18

19 Típuskonverzió Példa: int i; float f = 3.14; i = (int) f; // vagy... i = int (f); // C++-ban ez is elfogadott 19

20 Változó nevek A változó névnek a következő követelményeknek kell eleget tenne: Tartalmazhat betűket 'A'-'Z' és 'a'-'z' tartományban. Tartalmazhat számjegyeket '0'-'9' tartományban, de nem az első helyen. Tartalmazhat '_' karaktert. Nem tartalmazhat kulcsszavakat és műveleti jeleket. Hossza elvileg nem limitált, de gyakorlatban általában 255 karakter. 20

21 Szimbolikus konstansok const double PI = ; Definíciókor inicializálni! Ismételten már nem kaphat új értéket. Érvényes a const SIZE = 100; is, ekkor az alapértelmezett típus int. A konstanst a fordító több módszerrel kezelheti fordításidőben: immediate értékként, vagy regiszterben tartott változatlan értékként (pl. 0 értékű regiszter az avr-g++ esetén) Pointerekkel kapcsolatos megjegyzések: const int* size = 38 // integer konstansra mutató pointer változó int* const age = 42 // konstans pointer, ami integer változóra mutat *size = 40; // Hibás age = 0L; // Hibás age = size; // Hibás *age = 40; // Helyes size = 0L; // Helyes size = age; // Helyes Függvényekkel kapcsolatos megjegyzések: függvény bármelyik paramétere lehet konstans: int power (const int base, const int exponent); Stilisztikai megjegyzés: A konstansokat általába a header file-okban definiáljuk, hogy az értékük ismert legyen. 21

22 Példák HelloWorld.cc WeeklyPay_1.cc WeeklyPay_2.cc WeeklyPay_3.cc 22

23 2 Kifejezések Bármilyen számítási sorozat, aminek kiértékelhető eredménye van. Rendszerint a lényeg a kiértékelés során kapott eredmény, de a kiértékelés során más is történik: 1. kiszámítódik a számítási sorozat eredménye, 2. mellékhatások: néhány operátor a rendszer állapotában is változást idéz elő (pl. értékadás, inkrementálás, dekrementálás. Példa: cout << Hello << World ; Balról jobbra lesz végrehajtva. cout << Hello mellékhatása nyomtatás, visszatérő értéke a cout stream címe. Így a 23

24 (cout << Hello ) << World //második lépésben már egyenértékű lesz ezzel: cout << World 2.1 Aritmetikai operátorok Operátorok: + összeadás - kivonás * szorzás / osztás % maradék Figyelem! %-ot kivéve minden operátor int és real tetszőleges kombinációját elfogadja. % mindkét paramétere int. Ha mindkét operandus int, az eredmény int. Az egész osztás hozhat nem várt eredményt: 9 / 2 eredménye 4 (NEM 4.5)! -9 / 2 eredménye -5 (NEM -4)! Ha legalább az egyik operandus real, az eredmény is real (pontosabban double). Ha real eredményt akarunk: type cast (típusmódosítás), ellenkező esetben egészosztás történik. int dist = 100; int time = 10; double speed = dist / (double) time; Ügyelni kell a túlcsordulásra! A következő művelet rossz eredményt ad unsigned char a = 64 * 4 // az eredmény 0 lesz. 0-val osztás: fordítási időben az operandusokat nem ellenőrzi a fordító, 0-val osztás futásidejű hibát, és általában leállást eredményez. 2.2 Relációs operátorok A relációs operátor operandusai számértékkel kell, hogy rendelkezzenek. Kiértékelés után egy bool értékkel ekvivalens. 24

25 Operátorok: == egyenlőség!= nem egyenlőség <= kisebb egyenlő (sorrend!) >= nagyobb egyenlő (sorrend!) < kisebb > nagyobb Példa: 'A' < 'F' // helyes "HELLO" < "WORLD" // nem helyes 2.3 Logikai operátorok Nincs valódi beépített bool típus, eléggé elterjedt, hogy int-et használnak helyette. Operátorok:! negálás (unáris operátor) && Logikai ÉS Logikai VAGY Figyelem! Értéke valójában 0 vagy nem 0 lehet. Kiértékelés balról: ha a && baloldali feltétel nem teljesül, vagy a bal oldali feltétel teljesül, nem folytatódik a kiértékelés. Tehát a jobb oldali kifejezésnek ne szánjunk mellékhatást, mert nem biztos, hogy végre lesz hajtva! Példák:!130 // értéke && 3200 // értéke // értéke 1 (0xaa & 0x55) && 255 // értéke 0 (false) if ( (i<10) && (++i<n) ) /*...*/ // note that the condition increments i 2.4 Bitenkénti operátorok Operátorok: ~ bitenkénti negálás & bitenkénti ÉS bitenkénti vagy ^ kizáró vagy << léptetés balra >> léptetés jobbra Mivel a léptetés az implementáció függő előjelet nem tudja egységesen 25

26 26 kezelni, célszerű eleve előjeltelen vátozókon használni.

27 Példák: unsigned char x = '\011'; unsigned char y = '\045'; x: y: ~x: x & y: x & y: x ^ y: x << 1: x >> Auto inkrement - auto dekrement Prefix-ként: először műveletvégzés, majd az így nyert változót értékadáshoz használjuk Postfix-ként, elöször értékadás, majd művelet a változón. ++ inkrement (prefix / postfix) -- dekrement (prefix / postfix) Példák: int k = 10; int j = ++k; // j: 11, k: 11 int j = k++ // j: 10, k: Értékadó operátorok Érték letárolása valamilyen módon megadott memória címre. Az értékadó operátor egy olyan kifejezés, melynek értékét a bal oltali operandusban tárolni kívánjuk. lvalue írhatónak kell lennie, memória cím - egyelőre csak változó nevet láttunk példának. rvalue lehet változó, de lehet konstans (literal) is Tehát (lvalue = rvalue) hatására: 1. rvalue átmásolódik lvalue-be 2. visszatés az átmásolt értékkel, ami ismét használható rvalue-ként. Így lehetséges többszörös értékadás is. Az értékadást megelőzheti egy művelet (mellékhatással). = egyszerű értékadás += hozzáadás...ennek mintájára valamennyi bináris operátor használható az = jel bal oldalán! Példa: 27

28 // a többszörös értékadás alapja, hogy az értékadés mellékhatásán kívül // visszatérő értéke is van. int j, k, l; j = k = l =10; // ( j = (k = (l = 10))); j += k = l = 10 // j = j + (k = l = 10); 2.7 Feltételes operátorok Operátorok: operandus1? operandus2 : operandus3 ha op1 nem 0: op2 kifejezést kell kiértékelni, és ez lesz a visszatérő érték, ha op1 nulla: op3 kifejezést kell kiértékelni. és ez lesz a visszatérő érték. Példák: int j = 1, k = 2; int min = j < k? j : k; // Mivel a feltételes operátorok végül egy kifejezést képeznek, // több is egymásba ágyazható. int j = 1, k = 2, l = 3; int min = j < k? (j < l? j : l) : (k < l? k : l); 2.8 Vessző operátor Több kifejezés kiértékelése egyszerre. Visszatérő érték a legutolsó kif. értéke. Azoknak a kifejezéseknek, melyek nem visszatérő értékek, természetesen csak akkor van értelmük, ha van mellékhatásuk. Példa: int j, k, min; int jctr = 0, kctr = 0; min = j < k? jctr++, j : kctr++, k; 2.9 sizeof operátor Operandusa egy típusnév, vagy egy kifejezés. A visszatérő érték implementáció függő Pointerek Egy bizonyos memória hely címe. Értékére ritkán vagyunk kiváncsiak, többnyire hivatkozásként használjuk. Operátorok: * operátor jelentése: "point to" & operátor jelentése "address of" Példa: 28

29 int* ptr; char* ptrchar; int num; ptr = &num; Figyelem! A * mint dereferencia operátor: argumentuma egy pointer, ami feloldja a hivatkozást, tehát *ptr ekvivalens lesz a num-mal. A pointer definiálásakor meg kell adni, hogy milyen típusra mutat. A pointer típusától függetlenül lehet neki 0 értéket adni. (neve: null pointer) A pointer típusát lehet módosítani (type cast) pl. ptrchar = (char*) ptr; (csak indokolt esetben) típusfüggetlen pointer: void* anyptr; 2.11 Bővebben az elemi stringekről Hozzunk létre két stringet: char* str1 = "firstname"; char* str2 = "lastname"; Az eredmény: két /0-val lezárt karakterlánc a memóriában, és két pointer típusú változó, amely a karakterláncok kezdőcímét tartalmazza. Tehát: str1 = str2; nem a string tartalmát tölti át, csak egyik pointert a másikba. Ugyanakkor: str1 = "middlename"; Memóriában létrehoz egy stringet "middlename" és a címét str1-be tölti. A memóriában levő string átírása a következő függvénnyel végezhető el: <string.h> strcpy(char* dest, char* source) Figyelem! Létezik egy standard string osztály is, ami a std névtérben a <string> header segítségével érhető el. 29

30 2.12 Precedencia 30

31 3 Utasítások, vezérlési szerkezetek 3.1 Utasítások Szekvenciális műveletek mellékhatással. 1. Egyszerű utasítás: egyetlen utasítás ;-vel lezárva. Példa: int i; // egyszerú utasítás: vált definíció ++i; // művelet (mellékhatással) i + 8; // ; -vel lezárt kifejezés - művelet (mellékhatás nélkül) ; // null utasítás 2. Összetett utasítás, vagy blokk: közé zért egyszerű utasítások. Lehetővé teszik, hogy több utasítás írjunk oda, ahová egyébként csak egyet lehetne Korlátozzák az érvényességi kört (scope) Típusok: deklarációk hozzárendelés (értékadás) műveletek feltételes elágazások ciklusszervező utasítások végrehajtás vezérlők 3.2 Egyszerű feltételvizsgálat if (kifejezés) utasításblokk1; else utasításblokk2; Példa: if (account > 0) interest = account * debitpercentage; account = account + interest; // kiemelhető else interest = account * creditpercentage; account = account + interest; Példa feltételes kifejezéssel egyszerűsítve: account += account? ( account * debitpercentage : account * creditpercentage); Példa további egyszerűsítéssel: account += account * (account? debitpercentage : creditpercentage); 31

32 3.3 Egymásba ágyazott, többszintű feltételvizsgálat if (kifejezés1) utasítás1; else if (kifejezés2) utasítás2; Vagy: if (kifejezés1) utasítás1; else if (kifejezés2) utasítás2; 32

33 3.4 Elágazásos feltételvizsgálat Valójában használható lenne helyette az if - else if szerkezet, de a switch olvashatóbb. switch (kifejezés) case constant1: utasítások1; break; case constant2: utasítások2; break;... default: utasításokn; break; Példa: A, S, K, L mint kurzormozgató billentyűk: switch (key) case 'a': ++y; break; case 's': --y; break; case 'k': ++x; break; case 'l'; --x; break; default: cout << "Error\n"; break; 33

34 Vigyázat! A break elhagyása nehezen ellenőrízhető hibát okoz. Az utolsó break után beírt utasítást nem jelzi hibának - de nem is hajtja végre. 3.5 Ciklusszervezés while utasítással while (kifejezés) utasítások; kifejezés: ciklusfeltétel utasítások: ciklus törzs Figyelem! Végtelen ciklust a rendszer nem ellenőrzi 3.6 Ciklusszervezés do-while utasítással do utasítások; while (kifejezés); ritkábban használt akkor célszerű, ha mindenképp le kell egyszer futtatni a ciklust Figyelem! Végtelen ciklust a rendszer nem ellenőrzi 3.7 Ciklusszervezés for utasítással Leggyakoribb felhasználás: lépéses ciklus - ilyenkor inkább javasolt, mint while for (kifejezés1; kifejezés2; kifejezés3) utasítások; 1. kifejezés1 kiértékelésre kerül 2. Minden futási ciklusban ha kifejezés2 kiértékelésre kerül, 3. ha kifejezés2 nem 0, kifejezés3 és utasítások végrehajtása. Példa: long sum; // hatóköre kívül van a for ciklus törzsön. for (short i = 1; i < n; ++i) // i hatóköre kívü a cilustörzsön. sum += i; 34

35 ciklusváltozó hatóköre nem a ciklusmag, hanem maga a ciklus. bármelyik kifejezés lehet üres for utasítások egymásba ágyazhatóak minden kifejezés helyére több is beírható, ha használjuk a, (vessző) operátort. Természetesen csak az utolsó ad vissza értéket, de pl. több ciklusváltozót így lehet egyszerre inicializálni. Példák: for ( ; i!= 0; ) // megfelel: while (i!= 0) for (;;) // megfelel: (üres feltétel = true) végtelen ciklus for (i = 0, j = 0; i + j < n; ++i, ++j) utasítások; Vigyázat, gyakori hiba: for (...); // a ";" miatt a ciklus további része csak egyszer fut le.... CycleDemo.cc Sum.cc 3.8 Ciklusszervezés tartományra for utasítással Megadható egy halmaz, amin elemenként megy végig. for ( declaration : range ) statement; Példa: string str "Hello!"; for (char c : str) std::cout << c; std::cout << '\n'; 3.9 A continue utasítás Kihagyja a ciklusmag további végrehajtását és új ciklusfejet kezd. Példa: // Páros számok összeadása n-ig for (i = 0; i < n; ++i) if ((n % 2)!= 0) // elég lenne if (n % 2) is, de így olvashatóbb continue; sum += i; 35

36 3.10 A break utasítás Megszakítja a ciklus, vagy a switch futását. Példa: "gondoltam egy számot - 3 kisérlet" for (i = 0; i < 3; ++i) cin >> i; if (i == n) break; cout << "Wrong!\n"; if (i == n) cout << "gotja\n"; else cout << "looser\"; 3.11 A goto utasítás Alacson szintű ugró utasítás. Példa: for (i = 0; i < try; ++i) cout << "Enter password: "; cin >> pw; if (Verify(pw)) // check password for correctness goto out; // drop out of the loop out: cout << "Wrong!\n"; 3.12 A return utasítás Visszatérő érték generálása. Eddig csak a main() ben használtuk. return kifejezés; 36

37 4 Függvények Műveletszekvenciák csoportosítása. 4.1 A függvények részei: prototípus, vagy interfész (visszatérő típus, név, paraméterek vagy aláírás) törzs (utasítások) Használat: hívás. argumentumok kiértékelése (minden argumentum egy a megfelelő paraméterrel azonos típusú kifejezés) a fenti kifejezések eredményeinek hozzárendelése a megfelelő paraméterekhez függvénytörzs végrehajtása visszatérő érték átadása a hívónak Figyelem! nem-void függvény: kifejezés void függvény: utasítás. Példa int power (int base, unsigned int exp) // prototype: base és exp lokális változók int result = 1; // lokális változó for (int i = 0; i < exp; ++i)// végrehajtás result *= base; return result; // visszatérő érték int main (void) cout << "2 on the power of 3 is" power (2, 3); // függvényhívás 4.2 Függvény deklaráció A függvényt mindíg csak akkor szabad használni, ha már deklarálva volt. Definíció maga is deklaráció, ha elől van, de javasolt kigyűjtött deklarációk használata. Deklaráció - prototype-pal. Deklaráció interfészébe konkrét változó nevek nem kellenek, de javasoltak. A paraméter listában minden paraméternek kell típus, vesszővel nem lehet több azonos típusú paramétert felsorolni. 37

38 4.3 Függvény paraméterek és argumentumok Két paraméter típus C++ -ban (vegyesen is használható egy paraméter listában): Érték szerinti átadás: a függvény lemásolja az argumentumot (változások nem hatnak vissza). Referencia szerinti átadás: pointerrel, vagy referenciával. A függvény hozzáférést kap a paraméterhez, és változtathat rajta. Az alábbi példákban az increment függvény feladata, hogy a neki átadott változó értékét megnövelje. Erre a célra érték szerinti paraméterátadást nem használhatunk, mert az inkrementálás a függvénytörzsben csak az argumentum másolatán történik meg. Példa - átadás érték szerint változóban ROSSZ! void increment (int number); int main() int num = 4; increment(num); cout << num << '\n'; // kiíratás: 4 void increment (int number) fog dolgozni ++(number); // rossz, mert itt number másolatán Példa - pointer szerinti átadás void increment (int* nptr); int main() int num = 4; int* numptr = &num; increment(numptr); cout << num << '\n'; void increment (int* nptr) ++(*nptr); 38

39 Példa - referencia szerinti átadás void increment(int& number); int main() int num = 4; increment(num); cout << num << '\n'; void increment(int& number) ++number; 4.4 Hatókör Globális: Élettartamuk a program teljes futási ideje. Minden ami a program hatókörében van definiálva (tehát nem függvényben, vagy osztályban, vagy szeparált blokkban. Inicializálatlan globális változók értéke 0-ra van automatikusan beállítva. Mivel a teljes programból láthatók, névadás legyen egyedi! Lokális: Élettartamuk csak a blokk elejétől a végéig tart. Minden, ami utasításblokkon belül van. Függvényparaméterek a függvénytörzsön belül lokálisak. Névadásnak csak a blokkon belül kell egyedinek lenni. Ha a hatókörök egymásba ágyazódnak, a belső névadása felülírja a külsőt. Ha felülírt globálisra akarunk hivatkozni, azt a ::név jelöléssel lehet. Példa: int xyz; // xyz globális void fnc (int xyz) // xyz lokális a fnc-n belül if (xyz > 0) double xyz; // xyz lokális a blokkon belül //... ::xyz = 0; // hívatkozás a globális változóra 4.5 Argumentumok alapértelmezett értéke A default argumentumokat mindíg a paraméterlista végén kell felsorolni! Célszerű meghatározás a deklarációban. Lehet a definícióban is, de soha 39

40 nem mindkét helyen! Példa: int main() int a = 4; int b = 5; cout << add(a, b) << ", "; // teljes paraméterlista cout << add(a) << endl; // második argumentum elhagyva int add(int number1, int number2) return number1 + number2; 40

41 4.6 Parancssori argumentumok Parancssori konzol segítségével indított programnak szüksége lehet paraméterekre. A main() függvénynek két féle definíciója létezik: int main(void); int main(int argcj, char* argv[]); Az argc azt adja meg, hogy hány paramétert kapott a program a parancssorban. A második paraméter egy string tömb, aminek első, tehát 0 indexű eleme magának a programnak a neve, a többi pedig a parancssorban beérkezett paraméterek. Például a sum parancs: argc = 3; argv[0] értéke: "sum", argv[1] értéke: 2 stb. Példa: int main(int argc, int *argv[]) int sum = 0; for (int i = 1, i < argc; ++i) sum += argv[i]; cout << sum << '\n'; return 0; 4.7 Függvények túlterhelése A programot ovashatóbbá teszi, ha az azonos feladatot ellátó függvények azonos nevet kapnak. A C++ megengedi a függvények túlterhelését, azaz ugyanazon függvénynéven több függvény definiálását. A feltétel, hogy a függvényeket az argumentumok és a visszatérő érték típusai, tehát az u.n "aláírás" egyértelműen megkülönböztessék. Példák: long gettime(); void gettime(long* time); void gettime(int* hours, int* minutes); void gettime(int& hours, int& minutes); 41

42 4.8 Függvény pointerek Lehetséges a függvény címét letárolni és hívatkozni rá. 1. Legyen több olyan függvényünk, aminek két int paramétere van és inttel tér vissza: int f1 (int a, int b)... int f2 (int c, int d) Definiáljunk egy pointer típusú változót, ami egy ilyen függvényre mutat: int ( * fptr) (int, int) 3. Adjunk az fptr-nek értéket: fptr = &f1; De elegendő: fptr = f1; 4. Hívás: int result = fptr(5, 7); Példa: int increment(int a) return a+1; int main() int (*fncptr)(int); // fncptr = &increment; helyett elegendő: fncptr = increment; cout << fncptr(3) << endl; // eredmény: 4 return 0; 42

43 5 Összetett adattípusok 5.1 Tömbök Azonos típusú elemek halmaza. Hivatkozás sorrend alapján: tomb[index] Index 0...size-1 Neve csak a tömbnek van, az elemeknek nincs. Elemek összes lehetséges száma: dimenzió - nem keverendő össze a dimenziók számával. A dimenzió futás közben nem változtatható, mert fordításidőben kerül a memória lefoglalásra. Dimenzió túllépés eredménye: jó esetben futásidejű hiba generálódik, rossz esetben kiszámíthatatlan. Definíció: int a[3]; Figyelem! Dimenzióban ugyanaz, mint int* a; de ezt nem lehet definícióként használni, mert nem tudni, hogy mennyi memóriát kell foglalni. Inicializáció int a[3] = 2, 4, 6; int a[3] = 2, 4; // a[2] értéke 0 int a[] = 2, 4, 6; // a[] mérete 3 Hivatkozás A tömb neve index nélkül egy pointert ad vissza, ami a tömb első elemére mutat, de csak ha ez az egyszerűsítés nem egy olyan elemre mutat, ami maga is pointer (pl. két dimenziós tömb). Példa: int a[] = 2, 4, 6, 8; int* aptr = a; cout << a[0] << ',' << *aptr << endl; cout << a[1] << ',' << *++aptr << endl; // a két kiíratás ugyanazt adja cout << a[1] << ','<< *aptr + 1 << endl; // nem ugyanaz, mert * prioritásosabb, mint + cout << a[1] << ',' << *(aptr + 1) << '\n'; // így már ugyanazt adja Stringek A string egy karaktertömb. Lehetséges inicializálás: 43

44 char name[] = 'H', 'E', 'L', 'L', 'O'; // mérete 5 - nem string!!!! char name[] = "HELLO" // mérete 6, mert a '/0' is a végére kerül. Ez a tényleges string. Többdimenziós tömb A több dimenziós tömb tárolása valójában sorfolytonosan történik. int a[2][3] = 2, 4, 6, 8, 10, 12, ; Sorfolytonos tárolás int a[2][3] = 2, 4, 6, 8, 10, 12; Pointer aritmetika A pointerhez lehet egész számot hozzáadni, vagy abból elvenni. 5.2 Struktúrák Valójában hagyaték a C nyelvből. struct tipusnév típus1 vátozónév1; típus2 változónév2;... objektumnév ; A struktúra létrehoz egy új típusnév típust. Ha csak egy példányt akarunk, nem kell típusnév, az objektum azonnal létrehozható (objektumnév). Ekkor természetesen nem kapunk típusnevet, ami a továbbiakban használható lenne újabb ugyanilyen típusú objektum létrehozására. Példa: Person postman = "Robert", 55; // hívatkozás struktúra mezőre struktúrán keresztül: cout << postman.name << endl; // hívatkozás struktúra mezőre pointeren keresztül: Person *ptrpostman = &postman; cout << (*ptrpostman).name << ", " << ptrpostman->age << endl; 44

45 6 Az osztályokról általában Objektum: az OOP alapeszköze. Az OOP egyik alapelve a "becsomagolás" vagy "encapsulation". Lényege: egy objektumot alkozó összes tulajdonságot egy egységbe tömörítjük. Az objektumokat nem egyenként hozzuk létre, hanem egy előre definiált osztály példányosításával. Az osztály egy típust hoz létre, ami a beépített típusokkal azonos módon használható. A struktúra és a union lényegében speciális osztályok. C++-ban osztály a struct és a class kulcsszóval egyaránt létrehozható. Alkotóelemei: tagfüggvények, vagy metódusok adattagok, vagy tagváltozók. Felépítés: Fejléc (header): Osztálynév és alaposztályok (ezekből származtathatjuk az új osztályt). Törzs (body): Az osztály tagjainak (members) felsorolása 45

46 Példa: class Point private: // a default értelmezés: private int xcoord, int ycoord; bool active; public: void set(int, int); void move(int, int) ; Az osztályokat rendszerint a header file-ok tartalmazzák. A változóktól eltérően az extern minősítő használata osztályoknál nem szükséges. A jó olvashatóságot segíti, ha a deklarációk az osztályban (.h modulban), de a definíció a.cc modulban van. Nem kötelező, de egyre elterjedtebb gyakorlat az egy osztály - egy modul elv. 6.1 Tagfüggvények, vagy metódusok Az osztályra jellemző műveletek. Alkalmazhatók default argumentumok, és túlterhelhetőek, de vigyázni kell, hogy a híváskor a default argumentumok elhagyásával ne álljon elő olyan forma, ami az egyik túlterhelt változatot is kielégíti. A tagfüggvényeket az osztályban deklaráljuk. A definíció történhet ekkor is, vagy később, az osztályon kívül. Példa osztályon kívüli definícióra: void Point::set(int x, int y) xcoord = x; ycoord = y; void Point::move(int x, int y) xcoord += x; ycoord += y; // hívatkozás Point pt; pt.set( 15, 20); pt.move(10, 10); // azonban pt.xcoord = 10; // nem szabályos, mert xcoord privát változó 46

47 Egyszerűbb metódusokat célszerű inline-nak definiálni! // Osztály a header (.h) fájlban: class Point private: // a default értelmezés: private int xcoord, ycoord; bool active; public: inline void set(int x, int y) az osztályban xcoord = x; ycoord = y; void move(int, int); inline int getx() return xcoord; definiálva definiálva ; inline int gety() return ycoord; // osztályon kívüli definíció a forrás (.cpp) fájlban void Point::move(int x, int y) xcoord += x; ycoord += y; 6.2 Adattagok, vagy tagváltozók A változó definíciókkal azonos szintaxis. 6.3 Hozzáférési engedélyek public: bárki által hozzáférhető private: csak az osztályon belül hozzáférhető // inline függvény definiálható // osztálydeklarációban // osztálydeklarációban protected: csak az osztályon, és a belőle származtatott osztályokon belül hozzáférhető Ha az osztályt a class kulcsszóval hozzuk létre, az alapértelmezés: private, ha struct kulcsszóval, akkor az alapértelmezés public. 6.4 Konstruktorok Az objektumpéldány létrejöttekor automatikusan lefut. Neve ugyanaz, mint az osztályé. Paraméterlistája lehet változó (túlterhelt). 47

48 Visszatérő értéke nincs Hozzáférés: public Példa: Point::Point(int x, int y) xcoord = x; ycoord = y; Point::Point() xcoord = 0; ycoord = 0; // hívatkozás: Point p(10, 25); Point p(); 6.5 Destruktorok Jellemzően akkor használjuk őket, ha az objektumnak a megszűnése előtt meg kell szüntetnie az objektumon belül végzett memóriafoglalásokat (new - delete operátorok), vagy le kell zárni az objektum által megnyitott erőforrásokat. Destruktorból csak egy van. 6.6 Osztálytagok - osztályváltozók Az osztály tagjai deklarálhatók úgy is, mint static. Ebben az esetben az osztály példányosítása előtt, a definíció pillanatában létrejön egyetlen példány ezekből a tagokból. A továbbiakban minden létrejött példány ugyanazon egy osztályváltozót fogja használni. Hívatkozás: mivel nem példányhoz (objektumhoz) kötött, nem lehet rá objektumon keresztül hívatkozni, ezért az osztály nevén keresztül kell :: operátorral. Tagfüggvényre is megadható, de ennek csak akkor van értelme, ha az osztályt egyáltalán nem akarjuk példányosítani, hanem csak enkapszulációt akarunk. Egyetlen előnye, hogy a példányosítás esetenként néhány bájttal több memóriát igényel. 8 bites mikrokontrollereknél elterjedt vélemény hogy memóriát takarít meg - nem feltétlenül igaz. Akkor célszerű alkalmazni, ha kimondottan az osztályhoz kapcsolódóan akarjuk használni. Pl. példányok számlálása: 48

49 Példa: class Point public: static int objctr; // példány számláló int xcoord, ycoord; Point(int x, int y) // objctr-t itt nem szabad inicializálni!!! objctr++; // számláljuk a példányt xcoord = x; ycoord = y; // A static változót külön meg kell definiálni, mert a példányosításból kimarad. // Ez ugyanabban a szkópban lehetséges, ahol a tagfüggvények definíciója. int Point::objCtr = 0; // automatikusan is erre van beállíttva // példányosítás: Point p1; Point p2; Point*ptrP2 = &p2; cout << p1.xcoord << '\n'; // objektumváltozó közvetlen hívatkozás cout << ptrp2->xcoord << '\n';// objektumváltozó indirekt hívatkozás cout << Point::objctr << '\n'; // osztályváltozó hívatkozás 6.7 A this változó Az adott objektumon belül használható private változó. 49

50 Típusa: pointer, ami olyan konkrét típusú, mint maga az objektum. Az adott példányra mutat. Csak tagfüggvényekben érhető el. 6.8 Inicializációs lista class Point private: int xcoord, ycoord; public: Point (int x, int y) xcoord = x; ycoord = y; // Konstruktor 50

51 Helyette célszerűbb: class Point private: int xcoord; int ycoord; public: Point(int x, int y) : xcoord(x), ycoord(y) Az inicializációs listát meg lehet adni az osztály deklarációban, vagy a konstruktor osztályon kívüli definíciójában is. 6.9 Operátor túlterhelés Az elemi operátorok kibővíthetők, hogy osztályokon végezzenek műveletet: Unáris operátor esetén az újradefiniált operátor nem kap argumentumot, hanem a tagváltozókat értékeli ki. Ha egy operátornak csak unáris vagy, csak bináris formája van, akkor nem terhelhető túl, a másik formában. Példa ex66_class_operator: 51

52 class Point public: int xcoord, ycoord; // public, hogy ki lehessen íratni Point(int x, int y): xcoord(x), ycoord(y) // összeadás operátor Point operator + (Point &point) return Point(xCoord + point.xcoord, ycoord + point.ycoord); // negálás (unáris) operátor túlterhelése // az unáris operátor nem kap argumentumot, csak az osztálytagokon dolgozik Point operator - () return Point(-xCoord, -ycoord); ; int main() Point p1(2, 2); Point p2(4, 4); Point p3 = p1 + p2; cout << p3.xcoord << ", " << p3.ycoord << endl; p3 = -p3; cout << p3.xcoord << ", " << p3.ycoord << endl; return 0; 52

53 7 Öröklődés (származtatás, bővítés) Új osztályok hozhatók létre egy kiválasztott alaposztály tagjainak a bővítésével. Ehhez megadjuk az alaposztályt, és a hozzáadandó új tagokat. Ezenközben az alaposztályhoz történő hozzáférést lehet korlátozni. class új_osztály : public/protected/private alap_osztály Az alaposztály legmagasabb szintű hozzáférései a megadott szintre lesznek bekorlátozva. public: Az alaposztály public tagjai public lesznek. protected: Az alaposztály public tagjai protected lesznek. private: Az alaposztály minden tagja private lesz. Példa ex64_class_inheritence: class Polygon protected: int width, height; public: void set(int w, int h) width=w; height=h; ; class Rectangle: public Polygon public: int area () return width * height; 53

54 ; class Triangle: public Polygon public: int area () return width * height / 2; ; int main () Rectangle rect; Triangle trgl; rect.set(4, 5); trgl.set(4, 5); cout << rect.area() << '\n'; cout << trgl.area() << '\n'; return 0; A származtatott osztály nem örökli az alaposztálytól: a konstruktorokat, destruktorokat, a túlterhelt operátorokat, a barát osztályokat. Bár a konstruktorok nem öröklődnek, azok mégis meghívódnak legalábbis az alapértelmezés szerinti, vagyis paraméter nélküli változat. Ha más konstruktorra van szükség, azt külön inicializáló listával kell hívni. Példa ex65_class_inher_initlist: class Polygon protected: int width, height; public: Polygon(int w, int h): width(w), height(h) // konstruktor void set(int w, int h) width=w; height=h; ; class Rectangle: public Polygon public: Rectangle(int w, int h): Polygon(w, h) int area () return width * height; ; class Triangle: public Polygon public: 54

55 Triangle(int w, int h): Polygon(w, h) int area () return width * height / 2; ; int main () Rectangle rect(4, 5); Triangle trgl(4, 5); cout << rect.area() << '\n'; cout << trgl.area() << '\n'; return 0; 7.1 Barátosztályok (friendship) A barátosztály olyan egyébként teljesen független - osztály, melynek hozzáférése van a private vagy protected szintű tagokhoz. class Square; // kell, mert a Rectangle mindjárt hivatkozik rá // Téglalap osztály class Rectangle private: int width, height; public: int area () return (width * height); void convert (Square square); // a téglalapot egy megadott négyzettel azonos méretűre változtatja ; // Négyzet osztály class Square friend class Rectangle; private: int side; public: Square (int a) : side(a) ; void Rectangle::convert(Square square) width = square.side; // side-hoz csak azért férhet hozzá, mert friend 55

56 height = square.side; int main () Rectangle rect; Square sqr (5); rect.convert(sqr); cout << rect.area() << endl; return 0; A példában a rect.convert-nek megadható egy square objektum, minek hatására a rect-et egy ugyanilyen oldalhosszúságú négyzetté konvertálja. A négyzet (square) oldala ugyan private, de a friendship miatt a rect.convert hozzáférhet. 7.2 Többszörös öröklődés A C++ lehetővé teszi több osztály tulajdonságainak az átszármaztatását is: class új_osztály : public/protected/private alapo1, public/protected/private alapo2... Figyelem! Amennyiben a két alaposztályban ugyanaz a tag előfordul, mindenütt az alapo1::tag illetve alapo2::tag módon kell rá hivatkozni! 7.3 Polimorfizmus Ha egy osztály metódusa a virtual kulcsszóval kerül definiálásra, akkor a származtatott osztályokban ez a metódus újradefiniálható. 56

57 class Polygon protected: int width, height; public: void set_values (int a, int b) width=a; height=b; virtual int area () return (0); ; // származtatott osztály: class Rectangle: public Polygon public: int area () // úradefiniálva return (width * height); ; 7.4 Absztrakt osztály: Megtehetjük, hogy area()-t a Polygon-ban egyáltalán nem definiáljuk. Ekkor ezt jelölni kell: 57

58 virtual int area () =0; // tisztán virtuális függvény Ez esetben Polygon u.n. absztrakt osztály, a származtatott osztályokban pedig mindenképp kell definiálni a metódust. 7.5 Osztály template-ek Az osztályok generálását automatikusan is elvégezhetjük olyan módon, hogy ehhez típusnevet adunk meg paraméternek. template definíció: template <class T> class Coordinate public: T xcoord, ycoord; // a nyomtatás érdekében public Coordinate (T xarg, T yarg) // konstruktor xcoord = xarg; // fontos, hogy = legyen definiálva T-re! xcoord = yarg; void stepup () ++xcoord; // fontos, hogy ++ legyen definiálva T-re! ; Hivatkozás: Coordinate<int> intcoord (5, 5); intcoord.stepup(); cout << intcoord.xcoord << endl; Megtehetjük azt is, hogy bizonyos típusokra másképp definiáljuk az osztálytemplate-et. Pl. double tipusú paraméter esetén stepup() helyett legyen jumpup(): template <> class Coordinate <double> public: double xcoord, ycoord; Coordinate(double xarg, double yarg ) xcoord = xarg; ycoord = yarg; void jumpup() xcoord += 10.0; ; Hivatkozás: 58

59 Coordinate<double> doublecoord(5.0, 5.0); doublecoord.jumpup(); cout << doublecoord.xcoord << endl; 7.6 Implicit típuskonverzió Publikus öröklés esetén implicit típuskonverzió megy végbe, tehát: class Ember ; class Benzinkutas: public Ember ; // a benzinkutas ember class Parkoloor: protected Ember ; // a parkolóőr nem ember Nem publikus öröklés esetén lehetséges az explicit típuskonverzió, de ekkor a programozó felelőssége, hogy ezt helyesen tegye. 7.7 inline Függvények Abszolutérték számításra a (n > 0? n : -n) kifejezés használható. Ha ezt többször használjuk, célszerű ezt egy függvényben definiálni: int Abs (int n) return n > 0? n : -n; A fenti megoldás helyett célszerűbb az inline int Abs (int n) return n > 0? n : -n; Ha a függvény inline-ként van definiálva, a fordító megpróbálja befordítani minden egyes előforduláshoz a függvényt, tehát bemásolni annak végrehajtható kódját, és nem hívással intézni. Ezáltal a hívással járó adminisztráció megtakarítható. Figyelem! C++-ban az osztályon belül deklarált és definiált függvény alapértelmezése inline. A compiler figyelmen kívül hagyhatja az inline kulcsszót, ha túl nagy függvényről van szó. inline függvényt csak akkor érdemes definiálni, ha az nagyon rövid végrehajtható kódot eredményez, ellenkező esetben a hívással járó adminisztrációt ugyan megtakarítjuk, de a hosszabb végrehajtható kódot sokszorosítjuk. az inline függvény minden hívást megelőzően kell, hogy definiálva legyen. Ennek legjobb helye a header fájl, ami viszont rontja a program szerkezetét, és sérti az encapsulation elvet. 59

60 8 További ismeretek az adattipusokról 8.1 Union-ok Speciális struktúra, melyben a tagok ugyarra a memória címre vannak elhelyezve. union DataField int data; unsigned char d[4]; mydata; mydata.data = 2014; cout << mydata.d[0]; Létrehoz egy új DataField tipust // használat int - ként // hozzáférés byteonként Ha csak egy példányt akarunk, nem kell típusnév, az objektum azonnal létrehozható (mydata). Ekkor természetesen nem kapunk típusnevet, ami a továbbiakban használható lenne újabb ugyanilyen típusú objektum létrehozására. 8.2 Enumeráció Szimbolikus konstansok elfogadandó halmazának a definíciója. Az enumerációs konstansoknak nincs memória allokálva, fordítás időben léteznek. Értékek rendre: 0, 1, 2, 3, 4 enum north, south, east, west; Default értékek felülírhatók: enum north = 360, south = 180, west = 90, east = 15; Létrehozható típus és változó is enumeráció alapján: enum Direction north, south, west, east mydir; Létrehoz egy új Direction tipust Ha csak egy példányt akarunk, nem kell típusnév, az objektum azonnal létrehozható (mydir). Ekkor természetesen nem kapunk típusnevet, ami a továbbiakban használható lenne újabb ugyanilyen típusú objektum létrehozására. Switch szerkezetben célszerű enumerációt használni: 60

61 switch(d) case north:.. break; case south:.. break; 8.3 A fájlkezelés alapjai A fájlműveletek a következő headereken keresztül érhetők el: ifstream stream osztály olvasási műveletekhez ofstream stream osztály írási műveletekhez fstream stream osztály irás/olvasás műveletekhez Használata: #include <iostream> #include <fstream> using namespace std; int main() ofstream myoutfile("hello.txt"); if( myoutfile.is_open()) myoutfile << "Hello World" << endl; myoutfile << "Hello World Again" << endl; myoutfile.close(); char buffer[100]; ifstream myinfile("hello.txt"); if( myinfile.is_open()) while( myinfile.getline(buffer, 100)) // getline() a stream ref-t adja vissza, // vagy 0-t, ha vége cout << buffer << endl; myinfile.close(); else cout << "Cannot open input file" << endl; 61

62 8.4 Típusdefiníció Létrehozhatók új, saját típusnevek. typedef unsigned char int8_t; typedef char buffer[20]; Újabb jelölés: using unsigned char = int8_t; using char = buffer[20]; Lényegében mindkét jelölés ugyanaz, de vannak esetek, amikor csak a using használható (template-ek) Igazi hasznuk akkor jelentkezik, amikor a típusdefiníció túl összetett lenne. Ilyenkor javítja az olvashatóságot. typedef int (*fncptr)(int) prinfunctionpointer; 8.5 Dinamikus memória kezelés A programstacken kívül futásidőben igénybe vehető egy másik dinamikus memória terület, az u.n. heap is. A new operátor Memória területet foglal, argumentum: típus visszatérő érték: pointer a lefoglalt memória területre. A visszatérő érték pointere az argumentumban adott típusra mutat. 62

63 int *intptr = new int; Vigyázat! A lefoglalt memória nem az automatikus változók szabályai szerint működik! void fnc(void) char* text = new char[10]; // fnc() végrehajtása után a text változó megszűnik, de a lefoglalt memória nem. A delete operátor Felszabadítja a memória területet. delete intptr; // felszabadít egy objektumot delete [] text // felszabadít egy objektumokból álló vektort 8.6 Tárolási osztályok és típusminősítők. Tárolási osztályok auto int i; // Automatikus változó: a lokális változók élettartama korlátozott, ezért dinamikusan jönnek létre és pusztulnak el. Ritkán használjuk explicit módon, mert default a lokális változók esetében. register int i; // Legyen ez a változó az élettartama alatt regiszterben, HA LEHETSÉGES! Explicit módon nem használjuk, mert az optimalizálók ezt csinálják. (Bármikor utólag is beírható a programba.) static int func(void); // függvények esetén a forrásfile-ra szűkíti a hozzáférést. static int i; // változók esetén meggátolja az automatikus kezelést. extern int i; // globális változó bármelyik modulban definiálható. Extern esetén a fordító nem keresi az adott file-ban, hanem csak elteszi a hivatkozást, ami később lesz feloldva, ha minden egyéb előfordulás, és a definíció is megvan. const - lásd később 63

64 9 Egyéb osztálytulajdonságok 9.1 Bináris operátor túlterhelésről részletesen Legyen egy osztályunk: class Element public: Element(int value) : value(value) int getvalue() const return value; private: int value; ; Bináris operátor túlterhelhető négy féle módon: 1. Különálló függvény hozzáféréssel a public adattagokhoz: Element operator+(const Element& a, const Element& b) return Element(a.getValue() + b.getvalue()); Az operandusok: e1 + e2 == operator+(e1, e2) 64

65 2. Tagfüggvényként: class Element public: // Left operand is 'this'; right is 'other'. Element operator+(const Element& other) const return Element(value + other.value); //... ; Az operandusok: e1 + e2 == e1.operator+(e2) 3. friend függvényként class Element public: // Left operand is 'a'; right is 'b'. friend Element operator+(const Element& a, const Element& b) return a.value + b.value; //... ; Az operandusok: e1 + e2 == operator+(e1, e2) 4. Friend függvény, az osztályon kívül definiálva. U.az mint 3. class Element public: friend Element operator+(const Element&, const Element&); //... ; Element operator+(const Element& a, const Element& b) return a.value + b.value; e1 + e2 == operator+(e1, e2) 9.2 Konstans objektumváltozók Egy objektumváltozót lehet const-ként definiálni. 65

66 class Origo const int xcoord; const int ycoord; //... Viszont az inicializálás nem lehetséges deklaráláskor. class Origo const int xcoord = 0; // HIBÁS const int ycoord = 0; // HIBÁS //... A magyarázat az, hogy mire az értékadás lefut, a változót a default konstruktor már létrhozza, de csak olvashatóként. Megoldás: Konstruktor és inicializáló lista, mert az előbb hajtódik végre, mint a konstruktor törzse. class Origo Origo(int x, int y): xcoord(x), ycoord(y); const int xcoord; const int ycoord; Figyelem! Konstans objektumváltozóval nem lehet tömbméretet megadni, mivel csak futásidőben kap értéket. 9.3 Konstans osztályváltozók Gyakorlati jelentősége jóval nagyobb. Olyan állandókat definiálhatunk vele, melyet az osztály biztosít szabályozott hozzáféréssel. 66

3. Gyakorlat Ismerkedés a Java nyelvvel

3. Gyakorlat Ismerkedés a Java nyelvvel 3. Gyakorlat Ismerkedés a Java nyelvvel Parancssori argumentumok Minden Java programnak adhatunk indításkor paraméterek, ezeket a program egy tömbben tárolja. public static void main( String[] args ) Az

Részletesebben

C# nyelv alapjai. Krizsán Zoltán 1. Objektumorientált programozás C# alapokon tananyag. Általános Informatikai Tanszék Miskolci Egyetem

C# nyelv alapjai. Krizsán Zoltán 1. Objektumorientált programozás C# alapokon tananyag. Általános Informatikai Tanszék Miskolci Egyetem C# nyelv alapjai Krizsán Zoltán 1 Általános Informatikai Tanszék Miskolci Egyetem Objektumorientált programozás C# alapokon tananyag Tartalom Bevezetés Lokális változó Utasítások Szójáték Why do all real

Részletesebben

Osztály és objektum fogalma

Osztály és objektum fogalma Osztály és objektum fogalma A C++ programozási nyelv I. CPP1/ 1 Az osztály (class) class: adatok és módszerek (method) (függvények) együttese, amely absztrakt adattípusként működik. objektum: egy osztály

Részletesebben

OBJEKTUM ORIENTÁLT PROGRAMOZÁS JAVA NYELVEN. vizsgatételek

OBJEKTUM ORIENTÁLT PROGRAMOZÁS JAVA NYELVEN. vizsgatételek OBJEKTUM ORIENTÁLT PROGRAMOZÁS JAVA NYELVEN vizsgatételek 1. Az objektumorientált programozás szemlélete, az objektum fogalma 2. Az objektumorientált programozás alapelvei 3. A Java nyelv története, alapvető

Részletesebben

Információs Technológia

Információs Technológia Információs Technológia A C programozási nyelv (Típusok és operátorok) Fodor Attila Pannon Egyetem Műszaki Informatika Kar Villamosmérnöki és Információs Rendszerek Tanszék foa@almos.vein.hu 2010 szeptember

Részletesebben

C++ programozási nyelv Struktúrák a C++ nyelvben Gyakorlat

C++ programozási nyelv Struktúrák a C++ nyelvben Gyakorlat C++ programozási nyelv Struktúrák a C++ nyelvben Gyakorlat Nyugat-Magyarországi Egyetem Faipari Mérnöki Kar Informatikai Intézet Soós Sándor 2004. szeptember A C++ programozási nyelv Soós Sándor 1/12 Input-output

Részletesebben

117. AA Megoldó Alfréd AA 117.

117. AA Megoldó Alfréd AA 117. Programozás alapjai 2. (inf.) pót-pótzárthelyi 2011.05.26. gyak. hiányzás: kzhpont: MEG123 IB.028/117. NZH:0 PZH:n Minden beadandó megoldását a feladatlapra, a feladat után írja! A megoldások során feltételezheti,

Részletesebben

Bevezetés a C++ programozásba

Bevezetés a C++ programozásba Bevezetés a C++ programozásba A program fogalma: A program nem más, mint számítógép által végrehajtható utasítások sorozata. A számítógépes programokat különféle programnyelveken írhatjuk. Ilyen nyelvek

Részletesebben

Bevezetés a C++ programozási nyelvbe

Bevezetés a C++ programozási nyelvbe Miskolci Egyetem Általános Informatikai Tanszék Bevezetés a C++ programozási nyelvbe Oktatási segédlet Összeállította: Ficsor Lajos 2001. 1. A C++ programozási nyelv története A C++ programozási nyelv

Részletesebben

Programozás alapjai II. (9. ea) C++ többszörös öröklés, cast, perzisztencia

Programozás alapjai II. (9. ea) C++ többszörös öröklés, cast, perzisztencia Öröklés ism. Programozás alapjai II. (9. ea) C++ többszörös öröklés, cast, perzisztencia Szeberényi Imre BME IIT Egy osztályból olyan újabb osztályokat származtatunk, amelyek rendelkeznek

Részletesebben

Programozás III CSOMAGOK. Az összetartozó osztályok és interfészek egy csomagba (package) kerülnek.

Programozás III CSOMAGOK. Az összetartozó osztályok és interfészek egy csomagba (package) kerülnek. Programozás III CSOMAGOK Az összetartozó osztályok és interfészek egy csomagba (package) kerülnek. A Java is csomagok halmaza: csomagokban van a fejlesztő környezet és az osztálykönyvtárak is: rt.jar fájl

Részletesebben

Bevezetés a C programozási nyelvbe. Az Általános Informatikai Tanszék C nyelvi kódolási szabványa

Bevezetés a C programozási nyelvbe. Az Általános Informatikai Tanszék C nyelvi kódolási szabványa Miskolci Egyetem Általános Informatikai Tanszék Bevezetés a C programozási nyelvbe Az Általános Informatikai Tanszék C nyelvi kódolási szabványa Oktatási segédletek a levelező műszaki informatikus hallgatók

Részletesebben

OAF Gregorics Tibor: Minta dokumentáció a 3. házi feladathoz 1.

OAF Gregorics Tibor: Minta dokumentáció a 3. házi feladathoz 1. OAF Gregorics Tibor: Minta dokumentáció a 3. házi feladathoz 1. Feladat Szimuláljuk különféle élőlények túlélési versenyét. A lények egy pályán haladnak végig, ahol váltakozó viszonyok vannak. Egy lénynek

Részletesebben

Programozás C++ -ban 2007/4

Programozás C++ -ban 2007/4 Programozás C++ -ban 2007/4 1. Az adatokhoz való hozzáférés ellenőrzése Egy C programban a struktúrák minden része mindig elérhető. Ugyanakkor ez nem a legkedvezőbb helyzet. Több szempontból is hasznos

Részletesebben

Pénzügyi algoritmusok

Pénzügyi algoritmusok Pénzügyi algoritmusok A C++ programozás alapjai Az Integrált Fejlesztői Környezet C++ alapok Az Integrált Fejlesztői Környezet Visual Studio 2013 Community Edition Kitekintés: fordítás Preprocesszor Fordító

Részletesebben

Programozás alapjai C nyelv 5. gyakorlat. Írjunk ki fordítva! Írjunk ki fordítva! (3)

Programozás alapjai C nyelv 5. gyakorlat. Írjunk ki fordítva! Írjunk ki fordítva! (3) Programozás alapjai C nyelv 5. gyakorlat Szeberényi Imre BME IIT Programozás alapjai I. (C nyelv, gyakorlat) BME-IIT Sz.I. 2005.10.17. -1- Tömbök Azonos típusú adatok tárolására. Index

Részletesebben

1 Rev 1. A C++ programozás alapjai - segédlet

1 Rev 1. A C++ programozás alapjai - segédlet 1 A C++ programozás alapjai - segédlet Tartalomjegyzék 1 Bevezetés...5 1.1 POSIX specifikáció...6 1.2 Fordítók és fejlesztői környezetek...7 GNU-LINUX GCC...8 Windows Cygwin...8 Windows: MinGW...8 Az Eclipse

Részletesebben

C# gyorstalpaló. Készítette: Major Péter

C# gyorstalpaló. Készítette: Major Péter C# gyorstalpaló Készítette: Major Péter Adattípusok Logikai változó Egész szám (*: előjel nélküli) Lebegőponto s szám Típus Típusnév másképpen (egyenértékű) Helyigény (bit) Példa bool Boolean 8 (!) true,

Részletesebben

C# osztályok. Krizsán Zoltán

C# osztályok. Krizsán Zoltán C# osztályok Krizsán Zoltán Fogalma Önálló hatáskőrrel rendelkező, absztrakt adattípus, amely több, különböző elemet tartalmazhat. Minden esetben a heap-en jön létre! A programozó hozza létre, de a GC

Részletesebben

Bevezetés a Programozásba II 11. előadás. Adatszerkezetek megvalósítása. Adatszerkezetek megvalósítása Adatszerkezetek

Bevezetés a Programozásba II 11. előadás. Adatszerkezetek megvalósítása. Adatszerkezetek megvalósítása Adatszerkezetek Pázmány Péter Katolikus Egyetem Információs Technológiai és Bionikai Kar Bevezetés a Programozásba II 11. előadás 2014.05.12. Giachetta Roberto groberto@inf.elte.hu http://people.inf.elte.hu/groberto Adatszerkezetek

Részletesebben

Programozás 3. Dr. Iványi Péter

Programozás 3. Dr. Iványi Péter Programozás 3. Dr. Iványi Péter 1 Egy operandus művelet operandus operandus művelet Operátorok Két operandus operandus1 művelet operandus2 2 Aritmetikai műveletek + : összeadás -: kivonás * : szorzás /

Részletesebben

Programozás BMEKOKAA146. Dr. Bécsi Tamás 1. Előadás

Programozás BMEKOKAA146. Dr. Bécsi Tamás 1. Előadás Programozás BMEKOKAA146 Dr. Bécsi Tamás 1. Előadás Bemutatkozás Előadó: Dr. Bécsi Tamás St.106, (1)463-1044, becsi.tamas@mail.bme.hu Közlekedés-, és Járműirányítási Tanszék www.kjit.bme.hu Programozás

Részletesebben

Objektumorientált programozás C# nyelven III.

Objektumorientált programozás C# nyelven III. Objektumorientált programozás C# nyelven III. Kivételkezelés Tulajdonságok Feladatok Készítette: Miklós Árpád Dr. Kotsis Domokos Hallgatói tájékoztató A jelen bemutatóban található adatok, tudnivalók és

Részletesebben

Információs Technológia

Információs Technológia Információs Technológia (Struktúra, mutatók, függvényhívás) Fodor Attila Pannon Egyetem Műszaki Informatika Kar Villamosmérnöki és Információs Rendszerek Tanszék foa@almos.vein.hu 2010 október 14/21. Struktúra

Részletesebben

Elôszó a magyar kiadáshoz A Kiadó Elôszó

Elôszó a magyar kiadáshoz A Kiadó Elôszó Elôszó a magyar kiadáshoz A C programnyelvet eredetileg a Bell Laboratóriumban az UNIX operációs rendszerhez, az alatt fejlesztették ki PDP-11_ számítógépen. A kifejlesztése óta eltelt évek során bebizonyosodott,

Részletesebben

Programozási alapismeretek :: beadandó feladat. Felhasználói dokumentáció. Molnár Tamás MOTIABT.ELTE motiabt@inf.elte.

Programozási alapismeretek :: beadandó feladat. Felhasználói dokumentáció. Molnár Tamás MOTIABT.ELTE motiabt@inf.elte. Programozási alapismeretek :: beadandó feladat Készítő adatai Név: Molnár Tamás EHA: MOTIABT.ELTE E-mail cím: motiabt@inf.elte.hu Gyakorlatvezető: Horváth László Feladat sorszáma: 23. Felhasználói dokumentáció

Részletesebben

C programnyelv 1. Kedves Kollegina, Kolléga!

C programnyelv 1. Kedves Kollegina, Kolléga! C programnyelv 1 Kedves Kollegina, Kolléga! A jegyzetet Önnek készítettem azért, hogy referencia anyaga legyen a Programnyelv és a Programfejlesztés tárgyakhoz. Szeretném a segítségét igénybe venni abból

Részletesebben

Programozás I. 3. gyakorlat. Szegedi Tudományegyetem Természettudományi és Informatikai Kar

Programozás I. 3. gyakorlat. Szegedi Tudományegyetem Természettudományi és Informatikai Kar Programozás I. 3. gyakorlat Szegedi Tudományegyetem Természettudományi és Informatikai Kar Antal Gábor 1 Primitív típusok Típus neve Érték Alap érték Foglalt tár Intervallum byte Előjeles egész 0 8 bit

Részletesebben

Számítástechnika I. BMEKOKAA152 BMEKOKAA119 Infokommunikáció I. BMEKOKAA606. Dr. Bécsi Tamás

Számítástechnika I. BMEKOKAA152 BMEKOKAA119 Infokommunikáció I. BMEKOKAA606. Dr. Bécsi Tamás Számítástechnika I. BMEKOKAA152 BMEKOKAA119 Infokommunikáció I. BMEKOKAA606 Dr. Bécsi Tamás Bemutatkozás Előadó: Dr. Bécsi Tamás St.106, (1)463-1044, becsi.tamas@mail.bme.hu Közlekedés-, és Járműirányítási

Részletesebben

Java II. I A Java programozási nyelv alapelemei

Java II. I A Java programozási nyelv alapelemei Java II. I A Java programozási nyelv alapelemei Miskolci Egyetem Általános Informatikai Tanszék Utolsó módosítás: 2008. 02. 19. Java II.: Alapelemek JAVA2 / 1 A Java formalizmusa A C, illetve az annak

Részletesebben

15. Programok fordítása és végrehajtása

15. Programok fordítása és végrehajtása 15. Programok fordítása és végrehajtása Programok fordítása és végrehajtása. (Fordítás és interpretálás, bytecode. Előfordító, fordító, szerkesztő. A make. Fordítási egység, könyvtárak. Szintaktikus és

Részletesebben

4. Öröklődés. Programozás II

4. Öröklődés. Programozás II 4. Öröklődés Programozás II Mielőtt belevágunk Egy Tárgy típusú objektumokat tároló tömb i. elemében tároljunk el egy új tárgyat Rossz módszer: tomb[i].setnev( uj.getnev() ); tomb[i].setertek( uj.getertek()

Részletesebben

Bánsághi Anna anna.bansaghi@mamikon.net

Bánsághi Anna anna.bansaghi@mamikon.net ESEMÉNYVEZÉRELT PROGRAMOZÁS Bánsághi Anna anna.bansaghi@mamikon.net 2. ELŐADÁS - C# ÁTTEKINTÉS - 2 2015 Bánsághi Anna 1 of 64 TEMATIKA I. C# ÁTTEKINTÉS II. WPF III. Modern UI 2015 Bánsághi Anna 2 of 64

Részletesebben

Objektumorientált programozás C# nyelven

Objektumorientált programozás C# nyelven Objektumorientált programozás C# nyelven 1. rész Osztályok és objektumok Mezık és metódusok Konstruktor és destruktor Láthatósági szintek Névterek és hatókörök Osztály szintő tagok Beágyazott osztályok

Részletesebben

Programozás II. 2. Dr. Iványi Péter

Programozás II. 2. Dr. Iványi Péter Programozás II. 2. Dr. Iványi Péter 1 C++ Bjarne Stroustrup, Bell Laboratórium Első implementáció, 1983 Kezdetben csak precompiler volt C++ konstrukciót C-re fordította A kiterjesztés alapján ismerte fel:.cpp.cc.c

Részletesebben

PHP II. WEB technológiák. Tóth Zsolt. Miskolci Egyetem. Tóth Zsolt (Miskolci Egyetem) PHP II. 2014 1 / 19

PHP II. WEB technológiák. Tóth Zsolt. Miskolci Egyetem. Tóth Zsolt (Miskolci Egyetem) PHP II. 2014 1 / 19 PHP II. WEB technológiák Tóth Zsolt Miskolci Egyetem 2014 Tóth Zsolt (Miskolci Egyetem) PHP II. 2014 1 / 19 Tartalomjegyzék Objektum Orientált Programozás 1 Objektum Orientált Programozás Öröklődés 2 Fájlkezelés

Részletesebben

Bevezetés a programozásba 2

Bevezetés a programozásba 2 Bevezetés a programozásba 2 7. Előadás: STL konténerek, sablonok http://digitus.itk.ppke.hu/~flugi/ Vector int int main() { vector v(10); int int sum=0; for for (int i=0;i

Részletesebben

Objektumorientált programozás C# nyelven

Objektumorientált programozás C# nyelven Objektumorientált programozás C# nyelven 1. rész Osztályok és objektumok Mezık és metódusok Konstruktor és destruktor Névterek és hatókörök Láthatósági szintek Osztály szintő tagok Beágyazott osztályok

Részletesebben

Szoftvertechnológia alapjai Java előadások

Szoftvertechnológia alapjai Java előadások Szoftvertechnológia alapjai Java előadások Förhécz András, doktorandusz e-mail: fandrew@mit.bme.hu tárgy honlap: http://home.mit.bme.hu/~fandrew/szofttech_hu.html A mai előadás tartalma: Miért pont Java?

Részletesebben

Magas szintű programozási nyelvek 2 Előadás jegyzet

Magas szintű programozási nyelvek 2 Előadás jegyzet Magas szintű programozási nyelvek 2 Előadás jegyzet 1. Rendszerfejlesztés 0. lépés: Elemzés (analízis) 1. lépés: Tervezés a, technológia független rész b, technológia függő rész 2. lépés: Megvalósítás

Részletesebben

Programozás C nyelven (3. ELŐADÁS) Sapientia EMTE

Programozás C nyelven (3. ELŐADÁS) Sapientia EMTE Programozás C nyelven (3. ELŐADÁS) Sapientia EMTE 2015-16 Classic Empire - A turn Based Wargame Classic Empire is a real time, multiplayer, Internet-based game, featuring military, diplomatic, and economic

Részletesebben

Egységes és objektumközpontú adatbázis-kezelés (2. rész)

Egységes és objektumközpontú adatbázis-kezelés (2. rész) Egységes és objektumközpontú adatbázis-kezelés (2. rész) A folytatásában a bemutatjuk, hogyan kezelhetünk Qt rendszer alatt SQL sormutatót, és készíthetünk grafikus felületet programoknak a Qt Designer

Részletesebben

Java VI. Egy kis kitérő: az UML. Osztály diagram. Általános Informatikai Tanszék Utolsó módosítás: 2006. 03. 07.

Java VI. Egy kis kitérő: az UML. Osztály diagram. Általános Informatikai Tanszék Utolsó módosítás: 2006. 03. 07. Java VI. Öröklődés Miskolci Egyetem Általános Informatikai Tanszék Utolsó módosítás: 2006. 03. 07. Java VI.: Öröklődés JAVA6 / 1 Egy kis kitérő: az UML UML: Unified Modelling Language Grafikus eszköz objektum

Részletesebben

S z á m í t ó g é p e s a l a p i s m e r e t e k

S z á m í t ó g é p e s a l a p i s m e r e t e k S z á m í t ó g é p e s a l a p i s m e r e t e k 10. előadás Ami eddig volt Számítógépek architektúrája Hardver elemek Szoftver Gépi kódtól az operációs rendszerig Unix alapok Shell script Windows adminisztráció

Részletesebben

A PROGAMOZÁS ALAPJAI 1. Függvény mint függvény paramétere. Függvény mint függvény paramétere. Függvény mint függvény paramétere

A PROGAMOZÁS ALAPJAI 1. Függvény mint függvény paramétere. Függvény mint függvény paramétere. Függvény mint függvény paramétere 2012. április 10. A PROGAMOZÁS ALAPJAI 1 Vitéz András egyetemi adjunktus BME Híradástechnikai Tanszék vitez@hit.bme.hu Miről lesz ma szó? alaki szabályok használata - mintapélda használata - mintapélda

Részletesebben

Járműfedélzeti rendszerek II. 1. előadás Dr. Bécsi Tamás

Járműfedélzeti rendszerek II. 1. előadás Dr. Bécsi Tamás Járműfedélzeti rendszerek II. 1. előadás Dr. Bécsi Tamás A tárgy órái Előadás hetente (St101) csüt. 8:15 Bécsi Tamás C elmélet Ajánlott irodalom Dennis Ritchie: A C programozási nyelv Gyakorlat hetente

Részletesebben

Számítástechnika II. BMEKOKAA Előadás. Dr. Bécsi Tamás

Számítástechnika II. BMEKOKAA Előadás. Dr. Bécsi Tamás Számítástechnika II. BMEKOKAA153 1. Előadás Dr. Bécsi Tamás Bemutatkozás Előadó: Dr. Bécsi Tamás St.106, (1)463-1044, becsi.tamas@mail.bme.hu Közlekedés-, és Járműirányítási Tanszék www.kjit.bme.hu A tantárgyi

Részletesebben

Pál László. Sapientia EMTE, Csíkszereda, 2014/2015

Pál László. Sapientia EMTE, Csíkszereda, 2014/2015 Objektumorientált programozás Pál László Sapientia EMTE, Csíkszereda, 2014/2015 2. ELİADÁS Visual Basic bevezetı Visual Basic.NET nyelvi elemek 2 Visual Basic.NET programozási nyelv Nyelvi elemek: Általában

Részletesebben

JAVA PROGRAMOZÁS 3.ELŐADÁS

JAVA PROGRAMOZÁS 3.ELŐADÁS Dr. Pál László, Sapientia EMTE, Csíkszereda JAVA PROGRAMOZÁS 3.ELŐADÁS 2014-2015 tavasz Polimorfizmus, absztrakt osztályok, interfészek 2 Példa - Hengerprogram 3 Példa - Hengerprogram 4 Példa - Hengerprogram

Részletesebben

Programozás II gyakorlat. 6. Polimorfizmus

Programozás II gyakorlat. 6. Polimorfizmus Programozás II gyakorlat 6. Polimorfizmus Típuskonverziók C-ben: void * ptr; int * ptr_i = (int*)ptr; Ez működik C++-ban is. Használjuk inkább ezt: int * ptr_i = static_cast(ptr); Csak egymással

Részletesebben

Programozás II. Fájlkezelés

Programozás II. Fájlkezelés Programozás II. Fájlkezelés Kocsis Zoltán Tamás 2013. 03. 28 Fájlkezelés Az stdio.h-ban megadott FILE* típusú pointerrel és függvényekkel lehet elérni a fájlunkat. FILE *fp; /* fájl mutató (file pointer/handle)

Részletesebben

Feladat: Hogyan tudunk létrehozni egy olyan vector nevű tömb típust, amely egy háromdimenziós térbeli vektort reprezentál?

Feladat: Hogyan tudunk létrehozni egy olyan vector nevű tömb típust, amely egy háromdimenziós térbeli vektort reprezentál? Típus definiálás Ennek általános alakja: typedef típus név Feladat: Hogyan tudunk létrehozni egy olyan vector nevű tömb típust, amely egy háromdimenziós térbeli vektort reprezentál? typedef double vector[3];

Részletesebben

STL. Algoritmus. Iterátor. Tároló. Elsődleges komponensek: Tárolók Algoritmusok Bejárók

STL. Algoritmus. Iterátor. Tároló. Elsődleges komponensek: Tárolók Algoritmusok Bejárók STL Elsődleges komponensek: Tárolók Algoritmusok Bejárók Másodlagos komponensek: Függvény objektumok Adapterek Allokátorok (helyfoglalók) Tulajdonságok Tárolók: Vektor (vector) Lista (list) Halmaz (set)

Részletesebben

Programozás II. 4. Dr. Iványi Péter

Programozás II. 4. Dr. Iványi Péter Programozás II. 4. Dr. Iványi Péter 1 inline függvények Bizonyos függvények annyira rövidek, hogy nem biztos hogy a fordító függvényhívást fordít, hanem inkább az adott sorba beilleszti a kódot. #include

Részletesebben

osztályok kapcsolata Származtatatás C++ Izsó Tamás 2014. március 19. Izsó Tamás Származtatatás/ 1

osztályok kapcsolata Származtatatás C++ Izsó Tamás 2014. március 19. Izsó Tamás Származtatatás/ 1 Származtatatás C++ Izsó Tamás 2014. március 19. Izsó Tamás Származtatatás/ 1 Dinamikus tagváltozó az osztályban class RVektor { i n t n ; R a c i o n a l i s p ; p u b l i c : RVektor ( i n t n=10 ) :

Részletesebben

Programozási nyelvek Java

Programozási nyelvek Java Objektum-orientált szemlélet - Egységbe zárás (incapsulation) - Információ elrejtés - Öröklődés altípusosság dinamikus kötés Öröklődés Programozási nyelvek Java - kiterjesztem, kibővítem, megváltoztatom

Részletesebben

A C++ öröklés. (Előfeltétel: 12. tétel ismerete)

A C++ öröklés. (Előfeltétel: 12. tétel ismerete) Az öröklés fogalma: A C++ öröklés (Előfeltétel: 12. tétel ismerete) olyan alapvető programozási technika, amely lehetővé teszi, hogy a már meglévő osztályainkból újakat tudunk származtatni, valamint az

Részletesebben

Programozás alapjai C nyelv 4. gyakorlat. Mit tudunk már? Feltételes operátor (?:) Típus fogalma char, int, float, double

Programozás alapjai C nyelv 4. gyakorlat. Mit tudunk már? Feltételes operátor (?:) Típus fogalma char, int, float, double Programozás alapjai C nyelv 4. gyakorlat Szeberényi Imre BME IIT Programozás alapjai I. (C nyelv, gyakorlat) BME-IIT Sz.I. 2005.10.10.. -1- Mit tudunk már? Típus fogalma char, int, float,

Részletesebben

1. Alapok. Programozás II

1. Alapok. Programozás II 1. Alapok Programozás II Elérhetőség Név: Smidla József Elérhetőség: smidla dcs.uni-pannon.hu Szoba: I916 2 Irodalom Bjarne Stroustrup: A C++ programozási nyelv 3 Irodalom Erich Gamma, Richard Helm, Ralph

Részletesebben

Java II. I A Java programozási nyelv alapelemei

Java II. I A Java programozási nyelv alapelemei Java2 / 1 Java II. I A Java programozási nyelv alapelemei Miskolci Egyetem Általános Informatikai Tanszék Utolsó módosítás: 2009. 02. 09. Java II.: Alapelemek JAVA2 / 1 A Java formalizmusa A C, illetve

Részletesebben

Származtatási mechanizmus a C++ nyelvben

Származtatási mechanizmus a C++ nyelvben Származtatási mechanizmus a C++ nyelvben Miskolci Egyetem Általános Informatikai Tanszék CPP2 / 1 Az öröklődés s fogalma 1. Egy osztály deklarálható valamely más osztály(ok) leszármazottjaként. Az deklaráció

Részletesebben

Járműfedélzeti rendszerek II. 3. előadás Dr. Bécsi Tamás

Járműfedélzeti rendszerek II. 3. előadás Dr. Bécsi Tamás Járműfedélzeti rendszerek II. 3. előadás Dr. Bécsi Tamás 5.3. Mutatók,tömbök A mutató vagy pointer olyan változó, amely egy másik változó címét tartalmazza. A C nyelvű programokban gyakran használják a

Részletesebben

Java adattípusok Java programozás alapjai Egyszerű adattípusok (int, float) Osztályokkal objektumok Nincs külön mutató, referencia, címe operátor, helyette: objektumok csak dinamikusan hozhatok létre és

Részletesebben

Programozási nyelvek II. JAVA EA+GY 1. gyakolat

Programozási nyelvek II. JAVA EA+GY 1. gyakolat Programozási nyelvek II. JAVA EA+GY 1. gyakolat EÖTVÖS LORÁND TUDOMÁNYEGYTEM INFORMATIKAI KAR PROGRAMOZÁSI NYELVEK ÉS FORDÍTÓPROGRAMOK TANSZÉK 2017/2018. őszi félév Tartalom 1 Amit tudni kell a félévről

Részletesebben

Mit tudunk már? Programozás alapjai C nyelv 4. gyakorlat. Legnagyobb elem keresése. Feltételes operátor (?:) Legnagyobb elem keresése (3)

Mit tudunk már? Programozás alapjai C nyelv 4. gyakorlat. Legnagyobb elem keresése. Feltételes operátor (?:) Legnagyobb elem keresése (3) Programozás alapjai C nyelv 4. gyakorlat Szeberényi Imre BME IIT Mit tudunk már? Típus fogalma char, int, float, double változók deklarációja operátorok (aritmetikai, relációs, logikai,

Részletesebben

Programozás 1. Dr. Iványi Péter

Programozás 1. Dr. Iványi Péter Programozás 1. Dr. Iványi Péter 1 C nyelv B.W. Kernighan és D.M. Ritchie, 1978 The C Programming language 2 C nyelv Amerikai Szabványügy Hivatal (ANSI), 1983 X3J11 bizottság a C nyelv szabványosítására

Részletesebben

Informatika terméktervezőknek

Informatika terméktervezőknek Informatika terméktervezőknek C# alapok Névterület (namespace) using Osztály (class) és Obejtumok Metódus (function, procedure, method) main() static void string[] arg Szintaxis // /* */ \n \t Névadások

Részletesebben

Mechatronika és mikroszámítógépek 2017/2018 I. félév. Bevezetés a C nyelvbe

Mechatronika és mikroszámítógépek 2017/2018 I. félév. Bevezetés a C nyelvbe Mechatronika és mikroszámítógépek 2017/2018 I. félév Bevezetés a C nyelvbe A C programozási nyelv A C egy általános célú programozási nyelv, melyet Dennis Ritchie fejlesztett ki Ken Thompson segítségével

Részletesebben

Programozás I. Metódusok C#-ban Egyszerű programozási tételek. Sergyán Szabolcs sergyan.szabolcs@nik.uni-obuda.hu

Programozás I. Metódusok C#-ban Egyszerű programozási tételek. Sergyán Szabolcs sergyan.szabolcs@nik.uni-obuda.hu Programozás I. 3. előadás Tömbök a C#-ban Metódusok C#-ban Egyszerű programozási tételek Sergyán Szabolcs sergyan.szabolcs@nik.uni-obuda.hu Óbudai Egyetem Neumann János Informatikai Kar Szoftvertechnológia

Részletesebben

Programozás alapjai 1. (BMEVIEEA100)

Programozás alapjai 1. (BMEVIEEA100) Programozás alapjai 1. (BMEVIEEA100) Gyakorlat anyaga az 6. oktatási héten (4-5. gyakorlat) A 7. oktatási hét péntekje előbbre csúszik a 6. hét szombatjára, ezért a 7. heti anyagot a szokottnál előbb kapjátok

Részletesebben

Programozás C és C++ -ban

Programozás C és C++ -ban Programozás C és C++ -ban 2. További különbségek a C és C++ között 2.1 Igaz és hamis A C++ programozási nyelv a C-hez hasonlóan definiál néhány alap adattípust: char int float double Ugyanakkor egy új

Részletesebben

Programozás I. Első ZH segédlet

Programozás I. Első ZH segédlet Programozás I. Első ZH segédlet Ezen az oldalon: kiírás az alapértelmezett (hiba) kimenetre, sztring konkatenáció, primitív típusok, osztály létrehozás, példányosítás, adattagok, metódusok Kiíratás alapértelmezett

Részletesebben

INFORMATIKAI ALAPISMERETEK

INFORMATIKAI ALAPISMERETEK Informatikai alapismeretek középszint 1021 ÉRETTSÉGI VIZSGA 2011. május 13. INFORMATIKAI ALAPISMERETEK KÖZÉPSZINTŰ ÍRÁSBELI ÉRETTSÉGI VIZSGA JAVÍTÁSI-ÉRTÉKELÉSI ÚTMUTATÓ NEMZETI ERŐFORRÁS MINISZTÉRIUM

Részletesebben

Alkalmazott modul: Programozás

Alkalmazott modul: Programozás Eötvös Loránd Tudományegyetem Informatikai Kar Alkalmazott modul: Programozás Feladatgyűjtemény Összeállította: Giachetta Roberto groberto@inf.elte.hu http://people.inf.elte.hu/groberto Frissítve: 2015.

Részletesebben

Programozás BMEKOKAA146. Dr. Bécsi Tamás 2. előadás

Programozás BMEKOKAA146. Dr. Bécsi Tamás 2. előadás Programozás BMEKOKAA146 Dr. Bécsi Tamás 2. előadás Szintaktikai alapok Alapvető típusok, ismétlés C# típus.net típus Méret (byte) Leírás byte System.Byte 1Előjel nélküli 8 bites egész szám (0..255) char

Részletesebben

Programozás 5. Dr. Iványi Péter

Programozás 5. Dr. Iványi Péter Programozás 5. Dr. Iványi Péter 1 Struktúra Véges számú különböző típusú, logikailag összetartozó változó együttese, amelyeket az egyszerű kezelhetőség érdekében gyűjtünk össze. Rekord-nak felel meg struct

Részletesebben

PROGRAMOZÁS ALAPJAI (ANSI C NYELVEN)

PROGRAMOZÁS ALAPJAI (ANSI C NYELVEN) PROGRAMOZÁS ALAPJAI (ANSI C NYELVEN) Mérnök informatikus duális képzést támogató oktatási anyag Összeállította: Dr. Baksáné dr. Varga Erika Dr. Hornyák Olivér Gépészmérnöki és Informatikai Kar Informatikai

Részletesebben

Algoritmizálás + kódolás C++ nyelven és Pascalban

Algoritmizálás + kódolás C++ nyelven és Pascalban Algoritmizálás + kódolás nyelven és ban Motiváció A Programozási alapismeretek tárgyban az algoritmizáláshoz struktogramot, a kódoláshoz nyelvet használunk, a Közismereti informatikában (a közoktatásban

Részletesebben

Országzászlók (2015. május 27., Sz14)

Országzászlók (2015. május 27., Sz14) Országzászlók (2015. május 27., Sz14) Írjon programot, amely a standard bemenetről állományvégjelig soronként egy-egy ország zászlójára vonatkozó adatokat olvas be! Az egyes zászlóknál azt tartjuk nyilván,

Részletesebben

A Jáva programozási nyelv rejtelmei

A Jáva programozási nyelv rejtelmei Page 1 of 20 A Jáva programozási nyelv rejtelmei Tartalomjegyzék: Az alapok Egy példaprogram A program szerkezete Változók és értékek Megjegyzések a programban A fôprogram Vezérlési szerkezetek Kivételkezelés

Részletesebben

Programozási technikák Pál László. Sapientia EMTE, Csíkszereda, 2009/2010

Programozási technikák Pál László. Sapientia EMTE, Csíkszereda, 2009/2010 Programozási technikák Pál László Sapientia EMTE, Csíkszereda, 2009/2010 Előadás tematika 1. Pascal ismétlés, kiegészítések 2. Objektum orientált programozás (OOP) 3. Delphi környezet 4. Komponensek bemutatása

Részletesebben

Emlékeztető: a fordítás lépései. Szimbólumtábla-kezelés. Információáramlás. Információáramlás. Információáramlás.

Emlékeztető: a fordítás lépései. Szimbólumtábla-kezelés. Információáramlás. Információáramlás. Információáramlás. Emlékeztető: a fordítás lépései Forrás-kezelő (source handler) Szimbólumtábla-kezelés Fordítóprogramok előadás (A, C, T szakirány) Lexikális elemző (scanner) Szintaktikus elemző (parser) Szemantikus elemző

Részletesebben

INFORMATIKAI ALAPISMERETEK

INFORMATIKAI ALAPISMERETEK Informatikai alapismeretek emelt szint 1021 ÉRETTSÉGI VIZSGA 2011. május 13. INFORMATIKAI ALAPISMERETEK EMELT SZINTŰ ÍRÁSBELI ÉRETTSÉGI VIZSGA JAVÍTÁSI-ÉRTÉKELÉSI ÚTMUTATÓ NEMZETI ERŐFORRÁS MINISZTÉRIUM

Részletesebben

Dinamikus csatolású függvénykönyvtár készítése és használata Plugin-szerű betöltés Egyszeű C++ osztályok készítése

Dinamikus csatolású függvénykönyvtár készítése és használata Plugin-szerű betöltés Egyszeű C++ osztályok készítése FEJLETT PROGRAMOZÁSI NYELVEK, 2009 2. GYAKORLAT - Linux alatti C/C++ programozás Cél: Dinamikus csatolású függvénykönyvtár készítése és használata Plugin-szerű betöltés Egyszeű C++ osztályok készítése

Részletesebben

Bánsághi Anna anna.bansaghi@mamikon.net

Bánsághi Anna anna.bansaghi@mamikon.net ESEMÉNYVEZÉRELT PROGRAMOZÁS Bánsághi Anna anna.bansaghi@mamikon.net 1. ELŐADÁS - C# ÁTTEKINTÉS - 1 2015 Bánsághi Anna 1 of 84 TEMATIKA I. C# ÁTTEKINTÉS II. WPF III. Modern UI 2015 Bánsághi Anna 2 of 84

Részletesebben

Globális operátor overloading

Globális operátor overloading Programozás II. 9. gyakorlat Operátor overloading 2: Unáris operátorok, globálisan megvalósított operátorok, > operátorok Kivételkezelés, IO library Globális operátor overloading Előző alkalommal

Részletesebben

Objektum elvű alkalmazások fejlesztése Kifejezés lengyel formára hozása és kiértékelése

Objektum elvű alkalmazások fejlesztése Kifejezés lengyel formára hozása és kiértékelése Objektum elvű alkalmazások fejlesztése Kifejezés lengyel formára hozása és kiértékelése Készítette: Gregorics Tibor Szabóné Nacsa Rozália Alakítsunk át egy infix formájú aritmetikai kifejezést postfix

Részletesebben

C vagy C++? Programozási Nyelvek és Fordítóprogramok Tanszék. Pataki Norbert. Programozási Nyelvek I.

C vagy C++? Programozási Nyelvek és Fordítóprogramok Tanszék. Pataki Norbert. Programozási Nyelvek I. Programozási Nyelvek és Fordítóprogramok Tanszék Programozási Nyelvek I. Témák 1 Bevezetés 2 A C++ alapfilozófiája 3 Névterek/namespace-ek 4 Függvények 5 Referenciák C++-ban Motiváció A C és a C++ nyelv

Részletesebben

Tipp A Word makrók kimerítõ tárgyalását megtalálhatjuk az O Reilly gondozásában megjelent Writing Word Macros címû könyvben.

Tipp A Word makrók kimerítõ tárgyalását megtalálhatjuk az O Reilly gondozásában megjelent Writing Word Macros címû könyvben. 2. fogás Utazás a makrók birodalmába Gyorstalpaló tanfolyam, amelynek során meggyõzõdhetünk arról, milyen sokat segíthetnek a makrók a fárasztó és idõrabló feladatok automatizálásában. A Word 6-os és azutáni

Részletesebben

Programozási Nyelvek (C++) Összefoglaló

Programozási Nyelvek (C++) Összefoglaló Programozási Nyelvek (C++) Összefoglaló Somogyi Krisztián gondozásában 2009-12-22 1. tétel: Fordítás [fordítási egység; warning; error; g++ kapcsolók] A teljes programot általában lehetetlen egy fájlban

Részletesebben

strings.xml res/values/strings.xml fájlban hozzuk létre a hiányzó string adatforrásainkat A jelenlegi helyett ez álljon: <resources> <string

strings.xml res/values/strings.xml fájlban hozzuk létre a hiányzó string adatforrásainkat A jelenlegi helyett ez álljon: <resources> <string Resource Objects Adatforrás elemeket hivatkozás (referencia, mutató) segítségével használhatunk, ezek karakterláncok (stringek), képek, azonosítók vagy akár fájlok is lehetnek A mappastruktúra egységesen

Részletesebben

Számítógépek felépítése, alapfogalmak

Számítógépek felépítése, alapfogalmak 2. előadás Számítógépek felépítése, alapfogalmak Lovas Szilárd SZE MTK MSZT lovas.szilard@sze.hu B607 szoba Nem reprezentatív felmérés kinek van ilyen számítógépe? Nem reprezentatív felmérés kinek van

Részletesebben

2.3. A C nyelv utasításai

2.3. A C nyelv utasításai 2.3. A C nyelv utasításai A C szabvány hét csoportban osztályozza a C nyelv utasításait: Csoport Kulcsszavak, ill. jelölések Kifejezés utasítás Üres utasítás: ; Összetett utasítás: } Szelekciós utasítások:

Részletesebben

SZERVER OLDALI JAVASCRIPT. 3. hét Javascript nyelvi elemek

SZERVER OLDALI JAVASCRIPT. 3. hét Javascript nyelvi elemek SZERVER OLDALI JAVASCRIPT 3. hét Javascript nyelvi elemek NYELVI ALAPOK: Ez sajnos igen száraz anyag, Viszont a megértékhez és a nyelv elsajátításához kell. Próbáljuk meg random gifekkel feldobni. MIRŐL

Részletesebben

Fizika InfoRmatika Kémia Alapok. Az Erdélyi Magyar Műszaki Tudományos Társaság kiadványa. Megjelenik kéthavonta (tanévenként 6 szám)

Fizika InfoRmatika Kémia Alapok. Az Erdélyi Magyar Műszaki Tudományos Társaság kiadványa. Megjelenik kéthavonta (tanévenként 6 szám) Fizika InfoRmatika Kémia Alapok Az Erdélyi Magyar Műszaki Tudományos Társaság kiadványa Megjelenik kéthavonta (tanévenként 6 szám) 8. évfolyam 2. szám Felelős kiadó ÉQLY JÁNOS Főszerkesztők DR. ZSAKÓ JÁNOS

Részletesebben

Programozás alapjai. 5. előadás

Programozás alapjai. 5. előadás 5. előadás Wagner György Általános Informatikai Tanszék Cserélve kiválasztásos rendezés (1) A minimum-maximum keresés elvére épül. Ismétlés: minimum keresés A halmazból egy tetszőleges elemet kinevezünk

Részletesebben

Számítástechnika I. BMEKOKAA152 BMEKOKAA119 Infokommunikáció I. BMEKOKAA606. Dr. Bécsi Tamás 2. előadás

Számítástechnika I. BMEKOKAA152 BMEKOKAA119 Infokommunikáció I. BMEKOKAA606. Dr. Bécsi Tamás 2. előadás Számítástechnika I. BMEKOKAA152 BMEKOKAA119 Infokommunikáció I. BMEKOKAA606 Dr. Bécsi Tamás 2. előadás Console I/O bővebben Lásd mintaprogram 2015.09.21. Számítástechnika I. 2. Előadás 2 Számábrázolásról

Részletesebben

Statikus adattagok. Statikus adattag inicializálása. Speciális adattagok és tagfüggvények. Általános Informatikai Tanszék

Statikus adattagok. Statikus adattag inicializálása. Speciális adattagok és tagfüggvények. Általános Informatikai Tanszék Speciális adattagok és tagfüek Miskolci Egyetem Általános Informatikai Tanszék CPP7 / 1 Statikus adattagok Bármely adattag lehet static tárolási osztályú A statikus adattag az osztály valamennyi objektuma

Részletesebben

VB C++ C# JScript J# Common Language Specification. ADO.NET and XML. Base Class Library. Common Language Runtime. Operating System

VB C++ C# JScript J# Common Language Specification. ADO.NET and XML. Base Class Library. Common Language Runtime. Operating System P r o g r a m o z á s i n y e l v e k I I. C # E jegyzet másolata nem használható fel szabadon,az előadás anyagának kivonata. Ezen teljes jegyzetről,vagy annak bármely részéről bármely másolat készítéséhez

Részletesebben

A C# PROGRAMOZÁSI NYELV

A C# PROGRAMOZÁSI NYELV A C# PROGRAMOZÁSI NYELV 2010.02.23. Bevezetés C# nyelv jellemzői 2 Kis és NAGY betű érzékeny Minden utasítást pontos vessző zár. Utasítás zárójel a:,. .NET Framework keretrendszerek 3 Microsoft.NET Framework

Részletesebben