Az objektum-orientáltság

Az előadások a következő témára: "Az objektum-orientáltság"— Előadás másolata:

1 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.

2 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.

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

4 Objektum-orientált programnyelvek
C++ JAVA

5 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++ 2

6 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 3

7 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). 4

8 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

9 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 */ 6

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

11 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) 8

12 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 ; } 9

13 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! 10

14 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 ; } 11

15 Á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 12

16 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. 13

17 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); } 14

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

19 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 16

20 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 ; } 17

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

22 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” } 19

23 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) 20

24 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 } 21

25 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) 22

26 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. 23

27 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 ) 24

28 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ó. 25

29 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 26

30 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. 27

31 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; 28

32 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 29

33 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; } 30

34 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é 31

35 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; } 32

36 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 33

37 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ő. 34

38 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; 35

39 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! 36

40 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 37

41 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! } 38

42 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 ) ; 39

43 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! 40

44 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 ; 41

45 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ó. 42

46 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 } 43