Az objektum-orientáltság A legnépszerűbb paradigma a számítástechnikában Paradigma: világszemlélet, látás-és gondolkodásmód az adott fogalomkörben használt elméletek, modellek és módszerek összessége. 2019.07.01.

Objektum-orientált szoftverfejlesztés OO módszertan alkalmazásával a kifejlesztendő rendszert együttműködő objektumokkal modellezzük, a tervezés és az implementáció során pedig ezen objektumokat „szimuláló” programegységeket alakítunk ki. 2019.07.01.

Objektum-orientált módszertanok Rumbaugh Booch Coad UML 2019.07.01.

Objektum-orientált programnyelvek C++ JAVA 2019.07.01.

C++ eredete C++ elődje a C nyelv kifejlesztője: Bjarne Stroustrup AT&T Bell Laboratories, Murray Hill (New Yersey) 1980. C osztályokkal 1983. C++ 2019.07.01. 2

A C nyelv(Kernighan-Ritchie) hiányosságai Nem ellenőrzi a fv. argumentumok számát és típusát nem tartalmaz I/O utasításokat nem tartalmaz dinamikus memóriakezelést nem tartalmaz konstansokat 2019.07.01. 3

A C nyelv stratégiája Egy szövegfeldolgozó előfordítóval egészítették ki a fordítóprogramot és egy függvénykönyvtárat hoztak létre a gyakran előforduló, de a nyelvben nem megvalósított feladatok elvégzésére. Ezek nyelven kívüli eszközök használatuk elfogadhatatlanul körülményes (pl. malloc()) vagy veszélyes (pl. makrók megvalósítása #define-nal). 2019.07.01. 4

A C++ nem objektumorientált tulajdonságai Nem objektumorientált tulajdonságok (bővítések a hagyományos C-hez képest), amelyek még nem igénylik az objektumorientált gondolkodást 2019.07.01.

C++ megjegyzések // egysoros megjegyzések tehetők Pl: int *ptr ; // ez egy pointer Megmaradt a C stílusú megjegyzés is (többsoros megjegyzések kezelésére. Pl: int f (int a, float b double c) /* A függvény bemenő paraméterei: a: egész b: float c: double */ 2019.07.01. 6

Függvény prototípusa Prototípus megadásában újdonság: C-ben lehetőség (csak figyelmeztető üzenet) C++-ban kötelező 2019.07.01. 7

Függvény prototípusa A deklaráció leírja a - függvény nevét - a függvény visszatérési értékét - a függvény paramétereit (típusát és számát) 2019.07.01. 8

Példa függvény hívására prototípussal megadott fv. esetén #include <iostream.h> void display (char *s) ; { display („Hello world!”); } void display (char *s) { cout <<s ; } 2019.07.01. 9

Prototípus megadása Ha a függvény definíciója megelőzi a fv. hívást, akkor nem szükséges a prototípus! Ha a függvény definíciója nem előzi meg a fv. hívást, vagy a fv. másik fájlban van, akkor szükséges a prototípus! 2019.07.01. 10

Függvényparaméterek deklarálása void display (char *s) // Új stílus C++-ban { cout <<s ; } void display (s) // C-ben jó char *s; //C++-ban hiba!! { cout <<s ; } 2019.07.01. 11

Általános szabály egy C program C++-szal történő fordítása előtt Adjuk meg a függvények prototípusát! Használjunk új stílusú függvény deklarációs blokkokat 2019.07.01. 12

Inicializált függvényparaméterek (Default Function Arguments) A kezdeti értékadást a C++ kiemelt fontossággal kezeli, a függvényparaméterekre is kiterjeszti. Példa: void sajatfv ( int i=5, double d = 1.23) ; Ezt a fv-t a következőképpen hívhatjuk: sajatfv (12, 3.45) ; // mindkét alapérték felülíródik sajatfv ( 3 ) ; // mint myfunc (3, 1.23) ; sajatfv ( ) ; // mint myfunc (5, 1.23) ; sajatfv ( , 3.5 ) ; // Hiba: nem adhatunk úgy meg paramétert, hogy az előtte levőt ne adnánk meg. Egyébként kevesebbet adhatunk meg. 2019.07.01. 13

Példa #include <iostream.h> void show (int = 1, float = 2.3, long = 4 ) ; { show(); show(5); show(6, 7.8); show(9,10.11,12L); } 2019.07.01. 14

Példa folytatása void show ( int first, float second, long third) { cout <<‘’\nfirst = ‘’ << first ; cout <<‘’, second = ‘’ << second ; cout <<‘’, third = ‘’ << third ; } 2019.07.01. 15

Eredmény first = 1, second = 2.3, third = 4 first = 5, second = 2.3, third = 4 first = 6, second = 7.8, third = 4 first = 9, second = 10.11, third = 12 2019.07.01. 16

Változók deklarálásának a helye A C-ben blokk elején lehet egy változót deklarálni. C++ban bárhol lehet egy változót deklarálni Olvashatóbb kód! ( A változó deklarálása a felhasználás helyéhez közel lehet!) Példa: #include <iostream.h> void main() { cout << „Enter a number:”; int n ; cin >> n ; cout << „The number is: „ << n ; } 2019.07.01. 17

Példa: for ciklusban for ( int ctr = 0 ; ctr < MAXCTR ; ctr ++ ) 2019.07.01. 18

Változók hatóköre #include <iostream.h> void main() { for ( int lineno=0; lineno<3;lineno++) { int temp = 22; cout << „Line number<<linemo<<„temp”<<temp; } if ( lineno = = 4 ) //lineno elérhető, temp nem cout << „\n” } 2019.07.01. 19

Lokális és globális változók A C-ben ugyanolyan névvel definiált változók esetében a lokális változók precedenciája nagyobb. A C++-ban megmondhatjuk a compilernek, hogy a globális változót akarjuk használni. :: (scope operátor) 2019.07.01. 20

Példa #include <iostream.h> int amount = 123; // globális változó void main() { int amount = 456; //lokális változó cout << ::amount //globális cout << „\n”; cout << amount; //lokális } 123 456 2019.07.01. 21

inline függvények Problémák a makrókkal: - mindent gondolkodás nélkül helyettesít - a nyomkövetést nem tette lehetővé (egy sorba kellett írni) 2019.07.01. 22

Makrókra példa #define abs() (x<0)? -x: x int y, x =3; y=abs(x++); Azt várnánk, hogy x=4, y=3 lesz. Ezzel szemben y= (x++<0)? -x++: x++ helyettesítés miatt az eredmény: x=5, y=4 lesz. 2019.07.01. 23

inline függvények A makrok függvényként definiálhatók a C++-ban az inline kulcsszó segítségével Az inline típusú fv-ek törzsét a fordító befordítja a hívás helyére. Példa: inline int abs(int x) (return (x<0)? -x: x ) 2019.07.01. 24

inline függvények Mindig előbb kell definiálni őket, mint ahogy hivatkozunk rájuk. Előnyei: - megszünteti a bonyolult zárójelezést - optimalizálható. 2019.07.01. 25

Tudnivalók az inline függvényekkel kapcsolatban Nem lehetnek static változói nem használhat ciklusképző utasításokat a befordított fv-ek nem lehetnek rekurzívak nem tartalmazhatnak lokális tömböket 2019.07.01. 26

Paraméterátadás függvénynek A C-ben a függvényeknek a paraméterek átadása két módon valósulhat meg: - érték szerint - cím szerint ( az aktuális paraméterlistában címet kell átadnunk a függvénynek, a formális paraméterlistában pointert kell deklarálnunk, a függvény törzsében az indirekció operátorát kell alkalmaznunk. 2019.07.01. 27

Referencia típus A C++-ban létezik a referencia típus, amely egy alternatív nevet jelent az adott változóra. A referenciát a & operátor azonosítja. Példa: int egyikint; int &masikint = egyikint; 2019.07.01. 28

Referencia típus felhasználása Függvényeknek való paraméterátadás függvény által visszaadott érték független hivatkozások 2019.07.01. 29

Cím szerinti paraméter átadás #include <iostream.h> void main(void) { int j=0; f(&j); cout<<„j új értéke:”<< j << „\n”; //100 értéket írja ki } void f ( int *n) { *n = 100; } 2019.07.01. 30

Referencia típus #include <iostream.h> void main(void) { int j=0; f( j); //automatikusan a cím adódik át cout<<„j új értéke:”<< j << „\n”; //100 értéket írja ki void f ( int &n) { n = 100; //automatikusan a tartalmát veszi } // nem kell * operátor az n elé 2019.07.01. 31

Referencia típus visszatérési értékként n++ nem a címet növeli!!!!! int mynum=0; int &num() { return mynum; } void main() { int i; i=num(); num()=5; } 2019.07.01. 32

A const azonosító Jelentése a C-ben : a változó értéke csak olvasható Jelentése C++-ban u.e., csak itt, ahol egy konstans változót használhatunk, ott kifejezést is használhatunk 2019.07.01. 33

A const azonosító const változót csak konstans kifejezéssel lehet inicializálni. const deklarációk helyettesíthetik a define direktívával való deklarálást. Előny: debuggolásnál a const elérhető. 2019.07.01. 34

A const azonosító (Példa) #include <iostream.h> void main() { const int SIZE = 5; char cs [SIZE]; cout << „ A cs mérete: „ << sizeof cs; 2019.07.01. 35

A const azonosító pointer deklarációkban //konstans pointer char *const ptr = mybuf ; //const pointer *ptr = ‘a’; ptr = yourbuf ; // Hiba! //konstans sztringekre mutató pointer char const *ptr = mybuf ; //const-ra mutató pointer ptr = yourbuf ; *ptr = ‘a’; // Hiba! 2019.07.01. 36

A const azonosító függvények paraméterlistájában Használhatjuk arra, hogy egy függvény paramétereit ne módosíthassuk. Megadása a függvény prototípusában. Példa: // Node: egy struktúra int readonly (const struct Node *nodeptr); A Node struktúrát nem módosíthatjuk a függvényen belül 2019.07.01. 37

A const azonosító függvények paraméterlistájában Ez a paraméter még akkor is védett, ha a fv-en belül egy lokális pointert deklarálunk. Példa: int readonly (const struct Node *nodeptr); { struct Node *writeptr ; //OK! writeptr = nodeptr ; //Hiba! } 2019.07.01. 38

Függvény overload void swap ( int &a, int &b) { int h = a ; a = b ; b = h ; } void swap ( float &a, float &b) { float h = a ; a = b ; b = h ; } int x= 47, y=11; float r = 4.7; s= 1.1; swap (x, y) ; swap (r, s ) ; swap (x, s ) ; 2019.07.01. 39

Paraméter szignatúra Függvény neve visszatérési érték paraméterek száma és típusa void f1 ( char *str, int x = 0 ) ; void f1 ( char *str, float s = -1 ) ; f1 („nanu”) ; // Hiba! f1 („nanu”, 1) ; //OK! 2019.07.01. 40

new és delete operátorok new típus new (típus) float *f1 = new float; float *f2 = new float(3.14); delete f1 ; delete f2 ; 2019.07.01. 41

Előnyei a malloc() fv-hez képest Automatikusan a megfelelő méretű helyet foglalja, nem kell a sizeof operátor mindig megfelelő típusú pointert ad vissza, nem kell explicit típuskonverziót végrehajtani. Mindkettő átdefiniálható. 2019.07.01. 42

Példa #include <iostream.h> void main(void) { int *p ; if (! ( p = new int ) ) //helyfoglalás egy egész értéknek { cout << „ Memórifoglalási hiba!”; return ; } *p = 1000 ; cout << „A p-nél lévő egész értéke:” << *p << „\n”; delete p ; // a memória felszabadítása } 2019.07.01. 43