Alexin Zoltán 118 lap Programozás II. Egyetemi előadás fóliák a Szegedi Tudományegyetem programozó II. programozó közgazdász II., mérnök informatikus II., fizikusinformatikus II. és számítástechnika tanár II. évf. szakos hallgatók számára Készítette: Alexin Zoltán (2011) (C.) Copyright, Alexin Zoltán 2011, 2015 Szegedi Tudományegyetem Informatikai Tanszékcsoport 2011.
Alexin Zoltán 2/118 Programozás II., nappali és levelező tagozat, A kurzus teljesítésének feltételei I. Évközi számonkérés: Elérhető maximális pontszám: 100 pont (a) Előadáson teljesitendő egy írásbeli dolgozat (teszt), időpontja: 7-8 héten Elérhető maximális pontszám: 40 Teljesitendő minimális pontszám: 16 (40%) Megjegyzés: amennyiben a hallgató nem szerzi meg a minimális pontszámot egy javítási lehetőséget kell biztosítani (b) Egy projekt munka (kötelező program), a bemutatás határideje: december elején, gyakorlatvezetővel egyeztetett időpontig Elérhető maximális pontszám: 40 Teljesitendő minimális pontszám: 20 (50%) Megjegyzés: a gyakorlatvezetők a kurzus elején megadják a pontozási feltételeket, a pontszám a vizsgajegybe nem számit be! (c) Gyakorlati vizsga (programírás számítógép előtt) időpontja: utolsó hetek egyike nélküle nem lehet vizsgázni Elérhető maximális pontszám: 60 Teljesitendő minimális pontszám: 24 (40%) Megjegyzés: amennyiben a hallgató nem szerzi meg a minimális pontszámot egy javítási lehetőséget kell biztosítani II. Kollokvium Elérhető maximális pontszám: 100 Teljesitendő minimális pontszám: 50 Megjegyzés: amennyiben a hallgató nem szerzi meg a minimális pontszámot két javítási lehetőséget kell biztosítani Az elérhető összes pontszám: 200 (I. és II.) Mind a négy alkalommal el kell érni mindenben a minimumot, (ez 90 pont) továbbá még 10 pontot a 2-es osztályzathoz. Jegyek ponthatárai: 170 200 jeles (85%-) 150 169 jó (75%-) 130 149 közepes (65%-) 100 129 elégséges (50%) 99 (vagy valamelyik topicbol minimum alatti ismételt teljesítés esetén) elégtelen
Alexin Zoltán 3/118 Ajánlott irodalom Herbert Schildt: C/C++ Referenciakönyv Panem Kft Budapest (1998) Herbert Schildt: C/C++ Programmer s Reference (3rd extended edition) Osborne McGraw-Hill (2002) ISBN: 0072227222 Bjarne Stroustrup: The C++ Programming Language (special 3rd edition), Addison-Wesley (2000), ISBN: 0201 700735 Scott Meyers: Hatékony C++, ISBN: 9639193828, Scolar Kiadó Budapest, (2003) A. Koenig, B. E. Moo: Accelerated C++ (Practical Programming by Example) Addison-Wesley (2000) ISBN: 0-201-70353-X C. Hughes, T. Hughes: Mastering the Standard C++ Classes: An Essential Reference, New York, (1999) Clovis L. Tondo, Bruce P. Leung: C++ Primer Answer Book Massachusetts, (1999) Clovis L. Tondo, Scott E. Gimpel: C Programozási feladatok megoldásai Műszaki Könyvkiadó Budapest (1995) Kris Jamsa: C++ Kossuth Könyvkiadó Budapest (1997) James O. Coplien: Advanced C++ Programming Styles and Idioms Addison-Wesley (1992) B. W. Kernighan, D. M. Ritchie: A C Programozási Nyelv Műszaki Könyvkiadó Budapest (1985) Robert Sedgewick: Algorithms in C Addison-Wesley (1990)
Alexin Zoltán 4/118 Tartalomjegyzék Ajánlott irodalom... 3 I. Bevezetés: az objektum-orinetált programozás alapjai... 6 Az öröklődés... 7 Az objektumok egymáshoz való viszonya... 9 Az objektum-orinetált programozás előnyei... 10 II. A C/C++ programozási nyelv... 11 III. C/C++ erőforrások az egyetem oktató kabineteiben... 12 Változások a C++ nyelv szintaxisában... 14 IV. C/C++ érvényességi tartomány típusok... 21 A függyény-prototípus scope... 22 A blokk scope... 23 A függvény scope... 24 A global scope... 25 Hogyan használhatjuk a C-ben megszokott header fájlokat C++-ban?... 27 A fájl scope... 28 A blokk és a fájl scope átlapolása... 30 V. A névtér (namespace) scope... 32 VI. A class utasítás és a class scope... 37 Az osztály tagjainak láthatósága... 39 Hogyan nevezzük el az osztályok tagjait?... 41 Különbségek a C és a C++ között, struct, union?... 42 VII. Beágyazott osztályok, típusok (embedded classes and types)... 45 Az osztályok implementációja... 46 VIII. Az öröklődés (inheritence)... 53 A viruális öröklődés (virtual inheritence)... 55 IX. Objektumok életciklusa (létrehozás és megszüntetés), konstruktorok és a destruktor.. 56 A konstruktorok... 57 Az ős osztály konstruktorának kézi hívása... 60 A destruktor... 62 Mikor van szükség konstruktor és destruktor alkalmazására?... 63 Objektumok klónozása, avagy a (copy) másoló konstruktor... 69 X. Az operátor overloading... 71 Operátor eljárás megvalósítása osztály tagjaként... 76 Operátor eljárás megvalósítása global scope eljárásként... 77 Néhány különlegesebb operátor kiterjesztés... 78 Az inline és const függvények... 80 A volatile módosító használata... 87 Az iostream template... 88
Alexin Zoltán 5/118 XI. Virtuális eljárások, absztrakt osztályok, késői hozzárendelés... 89 Korai és késői hozzárendelés... 89 Virtuális eljárások használata... 91 Pure virtual eljárások és az absztrakt osztályok... 93 XII. A static memberváltozók és metódusok... 101 XIII. A static memberváltozók és metódusok... 101 A static tagváltozók... 101 A static metódusok... 102 Visszahívható (callback) függvények... 103 A privilegizált operációs rendszerek működésének alapelvei... 103 A callback eljárások tulajdonságai... 103 XIV. Kivételkezelés... 106 XVI. Függelék: fontosabb ANSI C eljárások és használatuk... 108 A main() eljárás paraméterei... 108 A C/C++ prepocesszor utasítások... 110 A szövegkezelés eljárásai (string.h)... 112 A matematikai könyvtár eljárásai (math.h)... 114 Az ANSI C standard stream B/K eljárásai... 116
Alexin Zoltán 6/118 I. Bevezetés 1967 Simula (Dahl és Nygaard) 1980-as évek eleje Smalltalk (Kay, Goldberg és Ingalls) 1980-as évek vége C++ (Stroustrup) Objective-C (Cox) Eiffel (Meyer) Az objektum-orientáltság paradigma első látásra nem a programozási nyelvet jelenti, hanem új módon történő szoftverfejlesztést. Az objektumokat állapotok és viselkedési tulajdonságaik egyesítésének tekinti, amelyek egy szoros és szabatos interfésszel kapcsolódnak egymáshoz. Elősegíti: az információ elrejtést az újrafelhasználást új analízis és tervezési eljárásokat új programozási stílus kialakulását. Az objektum-orientáltság három alappillére: Encapsulation & information hiding (magyarul kb. egységbezárás és információ elrejtés) Reusability, polymorphism & inheritence (magyarul kb. újrafelhasználás, polimorfizmus és öröklődés) Magasabb fokú absztrakció (az absztrakt adattípus = class)
Alexin Zoltán 7/118 Az objektum-orientált filozófia a következőkön alapul: Egységbezárás (adat elrejtés) Döntés arról, hogy milyen modulok szükségesek, a programot úgy kell partícionálni, hogy az adatok a modulok belsejében elrejtve legyenek Absztrakt adattípus Döntés arról, hogy milyen típusokra van szükség, minden típushoz definiálni kell az elvégezhető összes műveletet Objektum-orientáltság Döntés arról, hogy milyen osztályokra van szükség, a közös tulajdonságokat láthatóvá teszi az öröklődés Az öröklődés Bankszámla Csekkszámla Megtakarítási számla Különleges megtakarítási számla Betétkönyves számla Befektetési számla
Alexin Zoltán 8/118 A gyerek (leszármaztatott, angolul derived class) osztály örökli a szülő osztály (basic class, parent class) attribútumait (ezek az adat tagok), illetve a viselkedését (ezek a metódusok, vagy eljárások). Az öröklődés során lehetőség van a gyermek osztályban: Új adat tagok, attribútumok (memberek) felvételére, Új eljárások (metódusok) felvételére, A szülő osztályban meglévő eljárás viselkedésének (törzsének) módosítására. Példák: Jármű (szülő osztály) Gépjármű (gyerek osztály) Bankszámla (szülő osztály) Lekötött betétszámla (gyerek osztály) Windows Ablak (szülő osztály) Windows Dialógus Ablak (gyerek osztály) Nyomtató (szülő osztály) Postscript nyomtató (gyerek osztály) Természetes nyelvi mondatban ezt úgy fejezzük ki, hogy: a... [gyermek osztály] az egy... [szülő osztály], amely... [extra tulajdonságok]. Pld. A gépjármű az egy olyan jármű, amelynek a mozgását egy beépített motor biztosítja. A postscript nyomtató, az egy olyan nyomtató, amely a feladatát Postscript lapleíró nyelven is tudja fogadni. Alapfogalmak: Objektumok Osztályok Absztrakt adattípusok Üzenetek Öröklődés Polimorfizmus (az azonos feladatot ellátó eljárások tetszőleges környezetben ugyanazt a nevet viselik)
Alexin Zoltán 9/118 Az objektumok egymáshoz való viszonya Aggregáció (egyik objektum néhány meghatározott számú másikból épül fel) Asszociáció (egyik objektum felhasznál egy másik objektumot, az eljárásai törzsében, paraméter átadáskor; a pointerrel történő hivatkozás is használatnak minősül) Öröklődés (egyik osztály speciális esete egy másik osztálynak) A gyermek osztály szinte mindig kifinomultabb; több, jobban kidolgoztt eljárást tartalmaz, ezért helyes rájuk így is gondolni. A programozási nyelv lehetővé teszi az osztályok (absztrakt adattípusok), az öröklődés és a használat leírását. A használat során megkülönböztetünk kliens (aki igénybe veszi) és szerver objektumot (aki nyújtja a szolgáltatást). Az adattag nélküli osztályok tekinthetők hasznos eljárások egy erőforrásának, amelyekből öröklődéssel számos egyedi osztályt alkothatunk, adattagok hozzáadásával.
Alexin Zoltán 10/118 Az objektum-orientált programozás előnyei Milyen kritériumai vannak a jó programok elkészítésének? 1. Korrektség, verifikálhatóság 2. Robusztusság (figyelem az extrém abnormális esetekre) 3. Bővíthetőség (kiterjesztés és javítás) 4. Újrafelhasználhatóság 5. Integritás (autonóm, zárt komponensek) 6. Kompatibilitás (hasonló programokkal, adatcsere, helyettesíthetőség) 7. Hatékonyság 8. Hordozhatóság 9. Könnyű használhatóság 10. Karbantarthatóság (a karbantartás a szoftver életének nagy részén vonul végig)
Alexin Zoltán 11/118 II. A C/C++ programozási nyelv Bjarne Stroustrup, Bell Labs. (http://www.hitmill.com/programming/cpp/cpphistory.asp), első implementáció 1983, ötleteket vett át a Simula67-ből (osztályok, származtatott osztályok), Algol68-ból (operátor kiterjesztés), Ada (templatek), Clu, B CPL programozási nyelvekből Minden C program lefordítható C++ ban is (így futtatható is), azonban az nem garantált, hogy ugyanaz a tárgymodul jön létre! A C++ a C programozási nyelv magasabb absztrakciót lehetővé tevő objektum-orientált bővítése Nagy volumenű fejlesztések támogatása, névterek, információ elrejtés, csoportmunka, szigorú típus ellenőrzés
Alexin Zoltán 12/118 III. Erőforrások az egyetem oktató kabineteiben 1. GNU C/C++ for MSDOS A programfejlesztési környezet az Irinyi oktató kabinetekben a 224 és a 226-os teremben az N: disken található a N:\GNU alkönyvtárban. Mielőtt használni kívánja, el kell indítani az N:\BAT\GNU.BAT eljárást, ami az útvonalakat beállítja. Az N:\GNU\ZIP alkönyvtárban található.zip fájlokat minden hallgató hazaviheti és telepítheti a saját gépére. Az itt található GNU C/C++ 2.7.2 egy ingyenes (freeware) programcsomag. Ugyanebben az anyagban megtalálható a GNU Pascal 2.0 is. A fordító program neve gcc.exe, a szerkesztő programé ld.exe, a szövegszerkesztőé rhide.exe. 2. GNU C/C++ for Unix A home.cab.u-szeged.hu (rozi): GNU C/C++ 2.95.3 fejlesztési környezet található. Használatához nincs szükség semmilyen előkészítésre, minden felhasználó indíthatja. A program neve gcc. Gyári Motorola C/C++ fordító program neve: cc Sun WorkShop 6 update 2C5.3 (2001. május 15.) A sirius-on: A GNU C/C++ 2.95.3 verziója van meg (2001. március 15.) korszerű, fejlesztési környezet. A program neve gcc. A gyári SUN C/C++ fordító program neve cc, de nem működik. A forráskód szerkesztésére Unix operációs rendszerben a következő programok használhatók: vi, xedit, pico, xwpe, nedit, emacs, xemacs. 3. Visual C/C++ 6.0 (illetve a Visual Studio.NET 2005)
Alexin Zoltán 13/118 A programfejlesztési környezet az Irinyi oktató kabinetekben megtalálható. A programmal egyebek mellett 32 bites MS-DOS alkalmazások, Windows (API, MFC, EXE, DLL, Console Application) programok készíthetők. A 32-bites Win 2000/XP operációs rendszert elindítva a programok használhatók, a parancssori fordító használatához szükséges beállításokat a számítógépek elvégzik. A parancssori fordító neve: cl.exe. 4. STL A C++ programozáshoz használható általános célú template könyvtár, mind a siriuson, mind pedig a Visual C/C++ 5.0 (6.0) fejlesztői környezetben használható. A template könyvtár már telepítésre került, a dokumentációja viszont innen: /pub/program/c++/stl_doc/index.html érhető el. Az STL egy ingyenes (freeware) programcsomag, amit mindenki szabadon használhat olyan ANSI C/C++ fordító programokkal, amelyek képesek lefordítani a benne szereplő defíníciókat. A könyvtár lényegében néhány header fájl, amelyben paraméteres osztályok (templatek) és (template)paraméteres eljárások vannak. 5. Honlap Nemcsak a C/C++, hanem más programrendszerekkel kapcsolatos információk találhatók a honlapomon: http://www.inf.u-szeged.hu/~alexin/. Például: Prolog, funkcionális programozás, Oracle, programok használati rendje, levelezési listák, honlapok. Vannak helyben olvasható dokumentációk, amelyek csak azokon a gépeken olvashatók, amelyekre fel van mountolva a /pub/programozas-ii.
Alexin Zoltán 14/118 Változások a C++ nyelv szintaxisában Minden változás permanens bővítés, ami azt jelenti, hogy a továbbiakban is minden C program lefordítható C++ -ban is. (Fordítva természetesen nem igaz.) A C++ nyelv számára azonban új tárgymodul struktúra volt szükséges, ezért a visszafelé kompatibilitás miatt a fordító programnak tudnia kell, hogy C vagy C++ tárgymodult állítson elő. A fordító a parancs sorból veszi az ehhez szükséges információkat (az input fájl kiterjesztése szerint végez C vagy C++ fordítást), illetve parancssori paraméterekkel is lehet befolyásolni. (cl -TP C). Itt most a fontosabb változások szerepelnek: Egysoros megjegyzés. A régi /* és */ jelek közé zárt többsoros megjegyzés továbbra is használható int k ; // ez egy megjegyzés Blokk utasításban nem kell a típus/változó definícióknak megelőzniük a végrehajtható utasításokat. int sum(int a, int b) int c ; c = a ; int d ; d = b ; return c+d ; A for utasításban létrehozható ciklusváltozó az első paraméter helyén for(char c = 0, *p = "Alma" ; c < (char) strlen(p) ; ++c)...
Alexin Zoltán 15/118 Az eljárások default paraméterei long int sum(long a, long b = 0, long c = 0) return a+b+c ; az eljárás ezután meghívható sum(1) ; sum(2, 5) ; sum(1, 2, 3) ; Az eljárások visszaadott értéke bármilyen típusú lehet struct abc long tomb [40] ; ; abc fill(abc in, long f = 0) for (int i = 0 ; i < 40 ; ++i) in.tomb[i] = f ; return in ; Referencia típus (cím szerint átadott var paraméter) int strlen (char &str) int i ; for (i = 0 ; (&str)[i]!= '\0' ; ++i) ; return i ; Szigorú típus egyeztetés Prototípus megkövetelése Új utasítások: class, template, namespace,...
Alexin Zoltán 16/118 Referencia változók használata 1. Deklarációk: #include <stdio.h> int main() int k = 6 ; int l = 7 ; int &pk = k ; printf("1: %d %d %p(%d)\n", k, l, pk, pk) ; // 6 7 0x001F8820(6) //*((int **) &pk) = &l ; _asm lea eax, dword ptr l mov pk, eax pk = pk+2 ; // pk alias l printf("2: %d %d %d\n", k, l, pk) ; // 6 9 9 _asm lea eax, dword ptr k mov pk, eax pk = pk-1 ; // pk alias k printf("3: %d %d %d\n", k, l, pk) ; // 5 9 5 return 1 ;
Alexin Zoltán 17/118 _main PROC ; COMDAT ; 5 : push ebp mov ebp, esp sub esp, 228 ; 000000e4H... ; 6 : int k = 6 ; mov DWORD PTR _k$[ebp], 6 ; 7 : int l = 7 ; mov DWORD PTR _l$[ebp], 7 ; 8 : ; 9 : int &pk = k ; lea eax, DWORD PTR _k$[ebp] mov DWORD PTR _pk$[ebp], eax prológus referenciaváltozó létrehozása a veremben ; 10 : ; 11 : printf("1: %d %d %p(%d)\n", k, l, pk, pk) ; mov esi, esp a paraméterek mov eax, DWORD PTR _pk$[ebp] berakása a verembe mov ecx, DWORD PTR [eax] hátulról előrefelé push ecx mov edx, DWORD PTR _pk$[ebp] mov eax, DWORD PTR [edx] push eax az imp printf mov ecx, DWORD PTR _l$[ebp] eljárás meghívása push ecx DLL-ből mov edx, DWORD PTR _k$[ebp] push edx push OFFSET??_C@_0BB@PBLHLJOJ@1?3?5?$CFd?5?$CFd... call DWORD PTR imp printf add esp, 20 cmp esi, esp call RTC_CheckEsp ; 00000014H a cdecl eljárás kiürít a veremből 5*4 = 20 bájtot
Alexin Zoltán 18/118 ; 14 : _asm ; 15 : ; 16 : lea eax, dword ptr l lea eax, DWORD PTR _l$[ebp] az l változó címének kiegészítése a bp regiszterrel ; 17 : mov pk, eax mov DWORD PTR _pk$[ebp], eax ; 18 : ; 19 : pk = pk+2 ; mov eax, DWORD PTR _pk$[ebp] mov ecx, DWORD PTR [eax] add ecx, 2 mov edx, DWORD PTR _pk$[ebp] mov DWORD PTR [edx], ecx az új referencia tárolása a pk változóban a referenciaváltozó használata ; 20 : printf("2: %d %d %d\n", k, l, pk) ;// 6 9 9 mov esi, esp mov eax, DWORD PTR _pk$[ebp] mov ecx, DWORD PTR [eax] push ecx mov edx, DWORD PTR _l$[ebp] push edx mov eax, DWORD PTR _k$[ebp] push eax push OFFSET??_C@_0N@FDFNGKMI@2?3?5?$CFd?... call DWORD PTR imp printf add esp, 16 cmp esi, esp call RTC_CheckEsp ; 23 : _asm ; 24 : ; 25 : lea eax, dword ptr k lea eax, DWORD PTR _k$[ebp] ; 26 : mov pk, eax mov DWORD PTR _pk$[ebp], eax ; 27 : ; 00000010H az imp printf hívása
Alexin Zoltán 19/118 ; 28 : pk = pk-1 ; mov eax, DWORD PTR _pk$[ebp] mov ecx, DWORD PTR [eax] sub ecx, 1 mov edx, DWORD PTR _pk$[ebp] mov DWORD PTR [edx], ecx ; 29 : printf("3: %d %d %d\n", k, l, pk) ;// 5 6 5... ; 32 : return 1 ; mov eax, 1 visszatérési érték ; 33 : add esp, 228 cmp ebp, esp call RTC_CheckEsp mov esp, ebp pop ebp ret 0 ; 000000e4H Epilógus
Alexin Zoltán 20/118 Deklarációk szintaxisa a C/C++ nyelvben 1. Deklarációk: típus/attr ; init deklarátor lista 2. Init deklarátor lista: deklarátor = kifejezés, 3. Példák: int k, l, m ; int k=1, l=3, m=k+3 ; int a[2], b[3,4], *pint, ifgv(long) ; az utolsó sor az alábbi négy deklarációt rövidíti: int a[2] ; int b[3,4] ; int *pint ; int ifgv(long) ;
Alexin Zoltán 21/118 IV. C/C++ érvényességi tartomány típusok (scope) Scope: a forráskód egy pontosan meghatározott része (modul név (fájl), sor, kezdő és záró character pozíció). A scope lehet összefüggő illetve összefüggő forráskód részek halmaza. Egy scope kiterjedhet több modulra, amelyek különböző alkönyvtárakban vannak. A scope-ban definiált programobjektumok élettere általában csak erre a területre terjed ki. prototípus érvényességi kör int skip_over(file *file, char *pattern, long *) ; int skip_over(file *file, char *pattern, long *line) typedef unsigned long ULONG ; while (!feof(file)) char *p = pattern; while (*p!= '\0') c=fgetc(file); if (c == '\n') (*line)++; if (c == *p) ++p; else break; if (*p == '\0') return 1; return 0; formális paraméterek hatásköre az eljárás az ULONG típus hatásköre a külső blokk a p változó a blokkban érvényes
Alexin Zoltán 22/118 1. A függvény-prototípus scope long int sum(int a, int b) ; long int sum(int x, int y) ; void * (*proto_type(long int, char *b)) (const char *b, unsigned short int d) ; long int sum(int a, int a) ; helytelen int record_func(struct A int a; long b; *param) ; // a struct A csak a prototípusban érvényes! A függvény-prototípus scopeban használt azonosítók érvényessége a függvény paramétereket közrezáró zárójelek közötti forráskód részlet. void * (*proto_type(long int, char *b)) (const char *b, unsigned short int d) ; A prototípusban a paramétereket nem kötelező elnevezni, Ha azonban adok nevet, akkor egy paraméterlistában nem lehet név ütközés, Ha később ismét definiálom egy függvény prototípusát, más paraméter azonosítókkal, az megengedett. A fordító csak a típusokat tárolja.
Alexin Zoltán 23/118 2. A blokk scope A C/C++ programozási nyelv leggyakrabban előforduló érvényességi tartomány típusa. A block scopeban definiált programobjektumok érvényességi köre a blokk-utasítást határoló és (kapcsos zárójelek) közötti terület. Egy belső blokkban megismételt azonosítóval létrehozott programobjektum eltakarja a külső blokkbeli ugyanilyen nevű programobjektumot. Egymásba ágyazott blokkok esetén belűlről kifelé haladva keresi meg a fordító a megadott azonosítójú programobjektumot. A blokkba belépve létrejönnek a blokkban definiált programobjektumok, a blokkból kilépve megszűnnek. Az egymásba ágyazott blokkoknak megfelelő programobjektumok létrehozásának és megszüntetésének technikai megvalósítása veremmel történik. Ennek következménye, hogy a blokkból kilépve, az ott definiált programobjektumok fizikailag is megszűnnek létezni (a helyüket újabb programobjektumok foglalhatják el). if (pint!= NULL) int a ; if (k!= 4) double a ; a = 6.26 ; a = 3 * 2 ; else char a[20] = abcdefg ; printf( %s\n, a) ;
Alexin Zoltán 24/118 3. A függvény scope A C/C++ programozási nyelv eljárásaiban a formális paraméterek és a goto címkék érvényességi tartománya az a teljes eljárás (fej és törzs), amelyben azokat definiálták. Ennek két fontos hatása van: a formális paramétereket a blokkokban definiált lokális változók elfedhetik a blokkok között szabadon lehet ugrani a goto utasítással, azonban az eljárásból kiugrani nem lehet. Egy vezérlési szerkezetből (ciklus, feltételes utasítás) kiugrani megengedett, ellenben egy vezérlési szerkezet belsejébe beugrani nem logikus és rossz programozási stílus. int strlen (char *p) int len = 0 ; char *q = p ; if (p == NULL) goto exit ; len = 0 ; while(1) long p ; p = 4 * 12 ; if (*q == '\0') goto end ; ++q ; end : return len ; exit: return 0 ;
Alexin Zoltán 25/118 4. A global scope A global scope, a több modulból álló projekt egész területét jelenti. A C/C++ programozási nyelvben az (ún. globális) eljárások és az eljárástörzsön kívül definiált (ún. globális) változók érvényességi tartománya ez. Ez azt jelenti, hogy ha másként nem rendelkezik a programozó, akkor egy projekten belül minden globális változó és globális eljárás korlátozás nélkül látható, használható, illetve meghívható. /* a.c forrás fájl */ int a ; void seta(int b) a = b ; /* b.c forrás fájl */ #include <stdio.h> extern int a ; extern void seta(int) ; int main() a = 67 ; printf("a = %d\n", a) ; // az a a másik modulból seta(88) ; // seta a másik modulból printf("a = %d\n", a) ; Fordítás és futtatás: c:>cl a.c b.c c:>a.exe a = 67 a = 88
Alexin Zoltán 26/118 Tárolási osztályok a C nyelvben: register - a CPU egy regiszterében auto - veremszegmensben (csak eljáráson belül) static - adatszegmensben, lokálisan extern - adatszegmensben, globálisan (tárgymodulban extern-ként) a default: - adatszegmensben, globálisan (tárgymodulban public-ként) pl. auto int s ; register long k ; static char s[30] ; long int u ; A global scope érvényességű programobjektumok tárolási osztálya az extern volt. C++-ban az extern modifierrel jelezzük, hogy az adott program objektum a global scope-hoz tartozik. A programobjektum definiálásakor nem írunk extern-t (ez alapértelmezés automatikus). Ha kitesszük, akkor az azt jelzi, nem szükséges helyfoglalás, a programobjektum számára már korábban foglaltak helyet egy másik modulban. A C++ programozási nyelvben két új tárolási osztályt vezettek be a régebbi extern helyett az extern C és az extern C++ -t. Az utóbbi az alapértelmezett. extern C long int Sum(int a, int b) ; és az extern C++ long int Sum(int a, int b) ; vagy röviden: long int Sum(int a, int b) ; Ez a két eljárás C++ programozási nyelvben különbözik.
Alexin Zoltán 27/118 Hogyan használhatjuk a C-ben megszokott header fájlokat C++ban? A C-ben megismert és használt standard C header fájlok továbbra is használhatók C++-ban. Ehhez kisebb változtatást kellett rajtuk végrehajtani, amely után lehetséges a további használat. A C/C++ fordító program egy belső ún. define makró segítségével jelzi, hogy az éppen fordított modul C vagy C++ nyelvű. A makró neve: cplusplus. A standard header fájlok így néznek ki: #ifndef STDIO_H #define STDIO_H #ifdef cplusplus extern C #endif korábbi C nyelvű deklarációk pld. FILE * fopen (const char *, const char *) ; int fclose(file *) ;... #ifdef cplusplus #endif #endif // STDIO_H
Alexin Zoltán 28/118 5. A fájl scope Amennyiben nem kívánjuk, hogy a programobjektumaink a global scope-ba kerüljenek, akkor helyette használhatjuk a fájl scope érvényességi tartományt. Ezt a static módosító (modifierrel) alkalmazásával érhetjük el. Az adott programobjektum neve és címe ilyenkor nem kerül be a tárgymodulba, ami kizárja, hogy egy másik modul azonos nevű programobjektumával ütközés léphessen fel. static int Sum(int a, int b) return a+b ; static char filename[_max_path] ; Tárgymodulok felépítése: publikus szimbólumok (assemblyben: public) táblázata. Ebben a táblázatban a modulban definiált objektumok neve és eltolási címe. Lehet rájuk más modulból hivatkozni, vagy meghívni az eljárásokat. hivatkozott szimbólumok (assemblyben: extern + FIXUP lista). A modulban hivatkozott objektumok neve, amelyek definíciója nem található meg a modul forrásában. Az ismeretlen címek helyére 0x00 bájtokat tesz a fordító. A helyet, ahová az érvényes címet szerkesztéskor kell majd tenni, megjegyzi a FIXUP listán. gépi kód (bájtkód). Az ismeretlen címek helyén 0x00 bájtok állnak, a szerkesztő program javítja cseréli ki a szerkesztéskor megállapított érvényes eltolási címekre.
Alexin Zoltán 29/118 A tárgymodul belső felépítése FIXUP lista, az ext 1 szimbólum címét hová kell beilleszteni. Header public szimbólumok szimb 1 szimb 2.. szimb n 0x0010 0x016A.. 0x0CB6 extern szimbólumok _TEXT segment proc szimb 1 (bájt kód) call ext 2 proc szimb 2 call ext 1 ext 1 0x0077 knd 1.. 0x009F knd n1 ext 2 0x01A5 knd 2. 0x01DF knd n2 _DATA segment (adat bájtok) szimb 4 DW? ext k 0x034B knd k.. 0x04CE knd nk A knd i mutatja, hogy a cím mely részét kell beírni a megadott helyre, szegmenscím, 16 bites eltolási cím, 32-bites eltolási cím, 16- bites relatív cím, stb.
Alexin Zoltán 30/118 A blokk és a fájl scope átlapolása A C/C++ programozási nyelv blokkjaiban lehetőség van fájl scope érvényességű változók definiálására. if (k == 0) static int s = 0 ;... else static int s = 1 ; Ebben az esetben egy olyan változó jön létre, amely viselkedésében sztatikus, (a program teljes futási idejében létezik), viszont érvényességi köre csak blokk scope. Ez azt jelenti, hogy a két ugyanolyan nevű (s) változó az adatszegmens két különböző című helyén tárolódik (valóban két teljesen különböző változó lesz). Fontos tudni(!), hogy az inicializálás nem hajtódik végre csak egyszer, akkor amikor a fordítóprogram helyet foglal a változónak, a blokkba való belépéskor már nem. Az s változók megőrzik az értéküket, amit a blokkban való legutóbbi tartozkodáskor felvettek. Ha ismét belépünk a blokkba ezek rendelkezésre állnak. A static változók címét tetszés szerint továbbíthatjuk a programban (a változók mindig elérhetőek, nem úgy mint a veremben tárolt lokális változók).
Alexin Zoltán 31/118 void f() static int i = 0 ; void g() static int i = 0 ; Az f() és a g() eljárásokban használt két változó különböző lesz! Ezért a fenti példában nem lehet közös adatterületként használni őket. Helyette a következő megoldást képzelhető el: static int i = 0 ; void f() használom az i változót void g() használom az i változót
Alexin Zoltán 32/118 V. A névtér (namespace) scope [C++] A C++ programozási nyelvben egy új szolgáltatás áll a programozók rendelkezésére nagy rendszerek készítéséhez: ez a névtér. A névtér egy hierarchikus programobjektum-azonosító tárolási struktúra (vö. mappák, folderek). A programobjektumok elhelyezése a névterekben egyszerű. A keresési útvonal programozható. A megkezdett névtér folytatható, a folytatások száma nincs korlátozva. Szintaxis: namespace ::> namespace [identifier opt ] namespace-törzs namespace A int a ; namespace B int a ; short C(short k) ; namespace A int a ; // hiba: azonosító ütközés int b ; long C(int k) ;
Alexin Zoltán 33/118 A névtérbeli programobjektumokra történő hivatkozás: A::B::a. A hivatkozásnak teljesnek kell lennie, a névtér hierarchia minden azonosítójának kell benne szerepelni. Az azonosítókat a scope-resolution (scope feloldó) operátor (a ::) választja el egymástól. A global scope szintén egy névtér, amit jelezhetünk így ::Sum(23, 23) ; (az azonosítók elé tett :: jellel). A névtérbeli eljárások definíciója: long A::C(int k) return k+1 ; short A::B::C(short k) return k+1 ; A névtér implementációja: a tárgymodulba kimentett azonosítók megváltoztatásával. Lásd később. Keresési útvonal megadása: a using utasítással. Egymás után több using utasítást is írhatunk. A nem egyértelmű hivatkozások elkerülése a teljes útvonal megadásával mindenképpen javasolt. Szintaxis: using ::> using namespace scope ; Például: using namespace D ; using namespace E::F::G ;
Alexin Zoltán 34/118 namespace D int d1; void f(int); void f(char); using namespace D; int d1; // nincs ütközés a D::d1 -gyel namespace E int e; void f(int); namespace D // namespace folytatása int d2; using namespace E; void f(int); void f() d1++; ::d1++; D::d1++; d2++; e++; f(1); f('a'); // hiba, melyik ::d1 or D::d1? // ok // ok // ok: D::d2 // ok: E::e // melyik D::f(int) or E::f(int)? // ok D::f(char) Ez a példa a Microsoft Visual C/C++ 5.0 (6.0) MSDN Helpben a using utasításnál megtalálható.
Alexin Zoltán 35/118 /* a.cpp programfájl */ namespace Gyar namespace Telep int k ; int l ; int sum_kl() ; int Gyar::Telep::sum_kl() return k+l ; /* b.cpp programfájl */ #include <stdio.h> namespace Gyar namespace Telep extern int k ; extern int l ; extern int sum_kl() ; using namespace Gyar::Telep ; int main() A Gyar::Telep::k k = 56 ; helyett elég csak a k l = 45 ; printf("sum_kl() = %d\n", sum_kl()) ; fordítás: c:>cl a.cpp b.cpp futtatás: c:>a.exe sum_kl() = 101 minősített eljárásnév hivatkozás másik modulban definiált programobjektumokra Nem kell kiírni a Gyar::Telep:: prefixet
Alexin Zoltán 36/118 /* az a.cod fordítási lista fájl */ ; Listing generated by Microsoft (R) Optimizing Compiler Version 16.00.40219.01 TITLE.686P.XMM include listing.inc.model flat ; 14 : return k+l ; H:\H-Disk 20090326\VCProjects\a.cpp a tárgymodulból kilátszik a két azonosító 00003 a1 00 00 00 00 mov eax, DWORD PTR?k@Telep@Gyar@@3HA ; Gyar::Telep::k 00008 03 05 00 00 00 00 add eax, DWORD PTR?l@Telep@Gyar@@3HA ; Gyar::Telep::l ; 15 : 0000e 5d pop ebp 0000f c3 ret 0?sum_kl@Telep@Gyar@@YAHXZ ENDP ; Gyar::Telep::sum_kl _TEXT ENDS END extern C++ azonosítók képzése PUBLIC?l@Telep@Gyar@@3HA ; Gyar::Telep::l PUBLIC?k@Telep@Gyar@@3HA ; Gyar::Telep::k _BSS SEGMENT /* Begin of Stack Segment */?l@telep@gyar@@3ha DD 01H DUP (?) ; Gyar::Telep::l?k@Telep@Gyar@@3HA DD 01H DUP (?) ; Gyar::Telep::k _BSS ENDS PUBLIC?sum_kl@Telep@Gyar@@YAHXZ ; Gyar::Telep::sum_kl ; Function compile flags: /Odtp ; File h:\h-disk 20090326\vcprojects\a.cpp _TEXT SEGMENT?sum_kl@Telep@Gyar@@YAHXZ PROC ; Gyar::Telep::sum_kl ; 13 : 00000 55 push ebp 32-bites eltolási cím. 00001 8b ec mov ebp, esp A cím nincs kitöltve