Database Systems_______ 2000, Springusers.itk.ppke.hu/~eszdo/itk/prognyelv_vizsga.doc · Web...

Programozási nyelvek

2007

Elmélet

összeállította: Esztergár-Kiss Domokos

Programozási nyelvek 2007 - Elmélet

A kérdéseknél a választ az adott nyelvi elem általános leírásával, a lehetséges kérdések felvetésével kell kezdeni!

1. Szoftverek minőségi szempontjai, moduláris tervezés, a modularitás alapelvei 2. Nyelvi elemek, alapfogalmak, a programozási nyelvek lexikális elemei (jelkészlet,

azonosítók, literálok, megjegyzések) 3. Vezérlési szerkezetek, utasítások

Értékadás, szekvencia és blokk utasítás, feltétel nélküli vezérlésátadás, elágazási szerkezetek, ciklusszerkezetek (példák: Java, C++, Ada)

4. Típusok 1.Típusspecifikáció, típusmegvalósítás, típusosztályok, skalár típusosztály típusai a programozási nyelvekben, (példák: Java, C++, Ada)Pointer és referencia típusok, típusok ekvivalenciája (példák: C++, Ada)

5. Típusok 2.Típuskonstrukciók – tömbök, direkt szorzat, unió, halmaz támogatása (példák: Java, C++, Ada, Pascal, CLU)

6. Absztrakt adattípusok a programozási nyelvekbenProcedurális- és adatabsztrakciós megközelítés, elvárások és eszközök (példák: Java, C++, Ada)

7. AlprogramokEljárások és függvények, paraméterátadás-átvételi módok, túlterhelés, rekurzió (példák: Java, C++, Ada)

8. A kivételkezelésAlapfogalmai, kivételek kiváltása, terjedése, kezelése, specifikálása, kivételosztályok (példák: Java, C++, Eiffel)

9. SablonokTípussal, alprogrammal való paraméterezés, példányosítás, sablon-szerződés modell (példák: Java, C++, Ada, Eiffel)

10. Helyességbizonyítást támogató nyelvi eszközök (példák: Alphard, Eiffel) 11. Objektumorientált programozás 1.

Osztályok és objektumok, objektum létrehozása, inicializálása, példányváltozó, példánymetódus, osztályváltozó, osztálymetódus, társítási kapcsolatok(példák: Java, C++, Smalltalk)

12. Objektumorientált programozás 2.Öröklődés, polimorfizmus, dinamikus kötés, megbízható átdefiniálás leszármazottakban (példák: Java, C++, Eiffel)

13. Objektumorientált programozás 3.A többszörös öröklődés problémái, lehetséges megoldásai, az interfészek fogalma, használata (példák: Java, C++, Eiffel)

14. PárhuzamosságAlapfogalmak, kommunikációs modellek, szemafor, monitor, fontos nyelvi elemek (példák: Java, Ada)

- 2 -


1. Szoftverek minőségi szempontjai, moduláris tervezés, a modularitás alapelvei

Cél: jó minőségű program (termék)- ebben segít programozási módszertan, aminek eszköze a programnyelv;Szoftverek minőségi szempontjai:- Helyesség: ha pontosan megoldja feladatot, megfelel a kívánt specifikációnak (alapvető: pontos, teljes specifikáció);- Megbízhatóság: ha helyes és abnormális (specifikációban nem leírt) helyzetekben „ésszerű” működést produkál;- Karbantarthatóság: milyen könnyű a programot a specifikáció változatásához adaptálni (költségek 70%-a); alapelvek: tervezési egyszerűség, decentralizáció(önálló modulok);- Újrafelhasználhatóság: egészében v részében új alkalmazásokban felhasználható; (ésszerű módon lustának lenni)- Kompatibilitás: milyen könnyű a szoftver termékeket egymással kombinálni;- Hordozhatóság: milyen könnyű más géphez, konfigurációhoz, oprendszerhez átalakítani;- Hatékonyság: a futási idővel és a felhasznált memória méretével arányos (minél gyorsabb, minél kevesebb memóriát használ);- Barátságosság: emberközeliség, azaz logikus és egyszerű input, ill áttekinthető eredmények;- Tesztelhetőség: áttekinthetőség, karbantartók, fejlesztők számára fontos;

Programozási módszertan: strukturált, objektumorientált;fontos: moduláris tervezés: programot független, jól definiált kapcsolatban álló programegységként tervezni; - moduláris dekompozíció: - a feladat több egyszerűbb részfeladatra bontása (ezek megoldása egymástól függetlenül elvégezhető) csökkentjük a feladat bonyolultságát; - ismételten alkalmazzuk;- fával ábrázolható (csomópont: dekompozíciós lépés);- probléma: nem újrafelhasználható, nem karbantartható (pici változással felbomlik az egész programszerkezet);

- moduláris kompozíció:- szabadon kombinálható szoftverelemek;- a programokat már meglévő programegységekből (mint építőkövek) építjük fel, pl: STL;- probléma: hatékonyság háttérbe szorulhat;

- ezek kombinációja: programot nagy alfeladatokra bontom, de ezeket elemekből építem fel;

- 3 -


fontos:- moduláris érthetőség: a modulok önállóan is 1-1 értelmes egységet alkossanak, megértésükhöz minél kevesebb „szomszédos” modulra legyen szükség;- moduláris folytonosság: a specifikáció kis változtatása esetén a programban is csak kis változtatásra legyen szükség (számkonstansok mellőzése);- moduláris védelem: program egészének védelme abnormális helyzetek hatásaitól (hiba hatása néhány modulra korlátozódjon);

A modularitás alapelvei:- a modulokat nyelvi egységek támogassák: illeszkedjenek a használt programozási nyelv szintaktikai egységeihez; - kevés kapcsolat legyen: modul minél kevesebb másik modullal kommunikáljon;- gyenge legyen a kapcsolat: modulok a lehető legkevesebb információt cseréljék;- explicit interface kell: ha 2 modul kommunikál egymással, akkor legalább egyik szövegéből derüljön ki;- információ elrejtés: egy modulról minden információnak rejtettnek kell lennie, kivéve, amit explicit módon nyilvánosnak deklarálunk;- nyitott és zárt modulok: -- zárt: ha más modulok számára egy jól definiált felületen keresztül elérhető, a többi modul változatlan formában felhasználhatja;-- nyitott: ha kiterjeszthető (általa nyújtott szolgáltatások bővíthetőek vagy módosíthatóak további mezők hozzávételével);

Programozási nyelv:- eszköz a számítógép vezérléséhez, programozók közti kommunikációra, algoritmusok leírására, magas szintű tervezésre;- kialakulása: gépi kód- assembly nyelv- magas szintű nyelv(fordítóprogram);

Számítási modellek fajtái:- egyszerű operációs modell: Turing gép, automaták;- Neumann-féle modell: memóriát definiál, végrehajtás: bonyolult állapotok sorozata;- funkcionális modell: nincs memória, program lépései nem ismétlődnek;- objektum-orientált modell: valós világ modellezésével kapott objektumokból épül fel;- logikai alapú modell: kiegészítendő vagy eldöntendő kérdések logikai formulákkal megválaszolva;- Neumann elvű nyelvek: -- utasítás-orientált (utasítások egymás után v ismételten végrehajtva);-- változó fogalma;-- értékadás (kiszámított értékek tárolása);

Programozási nyelvek:Fortran(1950, tud), Lisp(rekurzió, din helyfogl,felszab), Algol60(adattípus, blokkszerk), Cobol(hierarchikus), Basic(oktatásra, interaktív), PL/1(pointer), Simula67(öröklődés), Algol68(többi prognyelv ebből), Pascal(oktatásra), C(rendszerporgr), Prolog(logikai), Ada(kivkez, sablon, párh), Smalltalk(objorientált), C++(1980), Eiffel, Java(1990), C#;

- 4 -


2. Nyelvi elemek, alapfogalmak, a programozási nyelvek lexikális elemei (jelkészlet, azonosítók, literálok, megjegyzések)

Szintaxis: szabályok összessége, melyek az adott nyelven írható összes lehetséges formailag helyes programot(jelsorozatot) definiálják;Szemantika: szabályok összessége, melyek az adott nyelv programjainak jelentését írják le;

Programok végrehajtása:- interpreter: utasítás lefordítása után azonnal végrehajtja;- fordítóprogram: átalakítja a programot egy ekvivalens formára (számítógép által közvetlenül végrehajtható v másik programozási nyelv);

- fordítás:-- forrásprogram: lefordítandó program;-- tárgyprogram: fordítás eredményeként kapott program;-- fordítási idő: amikor az utasítások fordítása folyik;-- végrehajtási idő: amikor az utasítások végrehajtása folyik;

Programszerkezet:-- programegység: egy részfeladatot megoldó (funkcionálisan összefüggő) programrész;-- fordítási egység(=modul): programegységek halmaza;a fordítóprogram egyszeri lefuttatásával a program többi részétől elkülönülten lefordítható; ha több modul, akkor fordítás és végrehajtás között összeszerkesztés;

Programegység részei:- specifikációs rész: leírja más egységekből elérhető kapcsolódási pontjait;- törzs: tartalmazza az egység funkcióját megvalósító programot; felépítése:-- dekarációs rész: azonosítók deklarációit, konstansok, típusok, objektumok, programegységek definícióit tartalmazza;-- utasítássorozat: utasításokat tartalmazza, melyek nyomán a programegység kifejti hatását;Blokkstruktúra: programegységek egymásba ágyazásával előálló hierarchikus struktúra;Deklaráció hatásköre kiterjed az összes tartalmazott programegységre.

- 5 -


Programegység fajtái: legelterjedtebb az alprogram: formális paraméterekkel rendelkezik, híváskor megfeleltetjük az aktuális paramétereknek; fajtái: eljárás és függvény;

- 6 -


Deklarációk:- hatáskör: programszöveg azon szakasza, amelyen belül az adott deklarációk érvényben vannak;- láthatósági kör: programszöveg azon szakasza, ahol az adott deklarációra hivatkozni lehet;láthatóság<= hatáskor;

- változódeklaráció formája: azonosító: típus, pl: N: Natural; típus azonosító, pl: int i;- deklarált azonosítók:-- globális: a tartalmazó által deklarált azonosítók; újradeklarálható: lokális eltakarja;-- lokális: a programegységben deklarált azonosítók;

- kiértékelés: feldolgozás, definíciók értelmezése;-- statikus: fordítási időben, pl: Modula,C;-- dinamikus: futási időben, pl: PL/I, Ada;

- túlterhelés:ugyanabban a szövegrészben több deklaráció;Erősen típusos nyelv: ha minden érték, objektum, formális paraméter, függvény típusa fordítási időben egyértelműen meghatározható;

- memóriakezelés:-- hozzárendelés: allokálás: automatikusan v programozó rendelkezik;-- felszabadítás: automatikus v programozó;-- élettartam: allokálás és felszabadítás közötti idő;

- statikus: -- élettartama a program egész működési idejére kiterjed; -- elhelyezés: statikus(main) memória területre; -- egyszer kerül lefoglalásra (program betöltésekor);- dinamikus:-- explicit módon foglal le területet a dinamikus(heap) memória területén (címére pointerrel hivatkozik);-- blokkstruktúrában: lokális változók végrehajtási veremben helyezkednek el;

- 7 -


Fordítási egység részei: lexikális elemek sorozata= karaktersorozatok határolójelekkel elválasztva;- grafikus karakterek: pl: Latin-1 v angol abc betűi, számai, speciális karakterek(pl: #<{);- formátumvezérlő karakterek: charachter tabulation(HT), line tabulation(VT), carriage return(CR), line feed(LF), form feed(FF);- egyéb vezérlő karakterek: implementációtól függ;

Lexikális elem: azonosító, numerikus literál, karakter literál, string literál, határoló, megjegyzés;

Karakter(=jel)készlet: különböző karakterek egy halmaza;- nem teszünk fel semmit a számítógép belső állapotáról, nem teszünk fel rendezést;- megadjuk: karakterek neveit és megjelenítését (lehet olyan, ami hasonló megjelenésű, mégis logikailag különböző, pl: A(latin), A(ciril), A(görög));Karakterkód: leképezés, amely kölcsönösen egyértelmű megfeleltetést ad a karakterkészlet karakterei és a nemnegatív egészek halmaza között (egyedi számkód táblázatból);Karakterkódolás: algoritmus karakterek digitális formában történő megadására (megadja, hogy kódszámokat hogyan képezi „oktetekké” ), pl: a- számkód: 97- oktetpár: (0,97), %- számkód: 8240- oktetpár: (32,48);

Milyen karakterek használhatóak egy nyelvben?- Pascal: minimum követelmények; 0..9 rendezett,folytonos, A..Z rendezett, a..z mint nagybetűk (ekvivalens), különböző implementációval különböző kódolás;- C++: alapkészlet 96 elemű: 0..9, A..Z, a..z (megkülönböztetve), speciális karakterek, ISO 10646 szerint kódolva;- Eiffel: ASCII megengedett (ekvivalens, de lehet ua objektumra és típusára);- Ada: ISO 10646 BMP (ekvivalens);- Java: Unicode 2.0 (megkülönböztetve);- C#: Unicode (megkülönböztetve);

Elhatároló jelek: általában helyköz(space) tab, sorvége;- egy karakterből álló: & ( ) + / <;- több karakterből álló: := ++ << &&;

- 8 -


Azonosítók: - Milyen karakterek használhatóak az azonosítók leírására?C#: Unicode 3.0 szerint kell írni; kulcsszavak @ jellel használhatóak azonosítóként is (pl: @bool), de @ jel azonosítót nem vezethet be;- Mi a megengedett szintaxis?ált: letter{letter|digit}, néha: ’_’ beszúrása is megengedett, pl:Pascal: letter{letter|digit}; Ada: letter{[_]letter|[_]digit};Java: Java_letter{[_]Java_letter|[_]digit};- Van-e hosszúsági megkötés?Fortran66: max 6 jel; Fortan90: max 31 jel; Ada: egy sorba férjen be; Pascal,Java: tetszőleges;- Vannak-e fenntartott szavak?Pascal,C,C++,Java,Perl,Ada95: fenntartott szavak nem használhatóak azonosítóként;Ada95: különbség kulcsszó és előredefiniált szó között; átdefiniálható, így implementáció-független;Fortan, PL/1: lehet kulcsszavakat azonosítóként használni;

Literálok:- Milyen numerikus literálok vannak?0..9, A..F, néha: ’_’, de space soha;- Milyen más alapok megengedettek 10-esen kívül?ált: decimális, néha: 2, 8, 16; Pascal, Modula, Oberon: csak decimális;C,C++,Java: oktális, decimális, hexadecimális; Ada95: minden alap 2 és 16 között, base#mantissa#[exponent], pl: 16#FFF.F#E1; Mathematica: minden alap 2 és 36 között;- Mi az egész ill valós literálok szintaxisa?-- egészek: decimális: [-]digit{digit}, pl: -123; Ada95,Perl,Eiffel: ’_’ is lehet; Ada95: exponenciális alak is, pl: 1E6; C,C++,Java,C#: int: 2, long: 2L, unsinged: 2LU;-- valósak: [-]digit{digit}.digit{digit}[exponent], pl: -123.456E+3; Ada: ’_’ is lehet; Pascal: [-]digit{digit}[exponent], pl: 12E+3; Eiffel: [-]{digit}.{digit}[exponent], pl: -1.- Többsoros string literálok megengedettek-e?- Vezérlőkarakterek string literálokban megengedettek-e?

Karakter: ’A’, ’\n’;String: különböző tárolás;

Megjegyzések:- szerkezet befolyásolhatja a program megbízhatóságát; lehetőségek:-- speciális oszloptól(jeltől) sor végéig;-- speciális jel(ek) elején- végén;-- speciális jel(ek) elején- vége a sor vége;Pascal: (* és *) vagy { és }; CLU: %-tól sor végéig; C++: /* és */ vagy //-tól sor végéig; Java: mint C++ vagy /** doksi */; Ada95,Eiffel: -- tól sor végéig;

- 9 -


3. Vezérlési szerkezetek, utasítások Értékadás, szekvencia és blokk utasítás, feltétel nélküli vezérlésátadás, elágazási szerkezetek, ciklusszerkezetek (példák: Java, C++, Ada)

Értékadás: := vagy = vagy -> vagy <- ; egyszerű utasítás;Kifejezés: operandusokból és operátorokból áll, pl: A+5;- kifejezés az értékadás? Igen(C, C++, Java); Nem(Pascal, CLU, Ada95, Eiffel);- többszörös értékadás? Igen(CLU); Nem(Pascal);

- Pascal: változónév:= kifejezés, pl: m: integer, m:=m+1; - CLU: referenciákat használ, 2 referencia hivatkozhat ugyanarra az objektumra, pl: x,y := y,x; - Ada95: változó és kifejezés típusa ua, pl: I: Integer range 1..10, J: Integer range 1..20, ekkor: I:=J error, J:=I OK; teljes rekordok és tömbök értékadása megengedett;- C++: értékadó operátor jobbról balra feldolgozva, pl: A=(B=C); számos értékadó operátor: =, /=, +=;- Java: számos értékadó operátor, pl: E1 op= E2 jelentése: E1= (T)((E2) op(E1)); ha összetett értékadó operátor, akkor mindkét operandusnak primitív típusúnak kell lennie; alapvetően referenciákat használ;- Eiffel: értékadás és paraméterátadás szemantikája ua; ha x:TX, y:TY, akkor x:=y?-- TX, TY referencia: referencia újrahozzárendelés;-- TX kiterjesztett, TY referencia: másolás;-- TX, TY kiterjesztett: másolás;-- TX referencia, TY kiterjesztett: klónozás;

Üres utasítás:- Pascal: megengedett, ’case’;- Ada95: null, ’case’;- C++,Java: ’;’ használható, pl: ciklusban üres törzs;- Eiffel: ’;’ használható, de nincs valódi szerepe;

Szekvencia: összetett utasítás;- Lehet-e üres?Ada95: lehet;- Terminátor vagy utasításelválasztó-e ’;’?Pascal: igen, pl: begin ut1; ut2; ut3 end; Ada95,C++,Java: ’;’ lezárja az utasítást; Eiffel: nem kell elválasztójel, de ’;’ megengedett;- Lehet-e blokkutasítást létrehozni?utasítások sorozatából alkotjuk;Pascal: begin utsorozat end; Ada95: [declare deklarációk] begin utsorozat [kivételkezelés] end; pl: Csere: declare Temp : Integer; begin Temp := I; I := J; J := Temp; end Csere; C++,Java: { és } között;- Elhelyezhető-e blokkutasításban deklaráció?bizonyos nyelvekben lehet deklarációs része is, de C-ben nem;

- 10 -


Feltétel nélküli vezérlésátadás: gotolehetőleg nélküle, ha mégis: - Pascal, C: címke: utasítások goto címke;- Modula-3, Java: nincs;

Elágazások:feltétel igaz vagy hamis értékétől függően valamely utasítás(csoport) végrehajtása;ált: if feltétel then ut1 else ut2;- csellengő else: if felt1 then if felt2 then ut1 else ut2 jelentése: if felt1 then (if felt2 then ut1 else ut2) vagy if felt1 then (if felt2 then ut1) else ut2; megoldás: -- blokk utasítás kell a beágyazásnál; -- else legbelső if-hez tartozik; -- explicit end bevezetése;- Többirányú elágazások:elsif lehetősége;if felt1 then s1; elsif felt2 then s2; elsif felt3 then s3; else s4; end if;

- Pascal: if felt then s1 [else s2]; több utasítás, akkor blokk kell; csellengő else: legbelső if; pl: if felt1 then if felt2 then s1 else s2, különben blokk: if felt1 then begin if felt2 then s1 end else s2; pl: if expre then; st1 if expr begin end; st1; hiba: if expr then s1; else s2!!;- Ada95: végén: end if; elsif megengedett; pl: if <expr>1 then <statm>1; {elsif <expr>2 then <statm>2;} [else <statm>3;] end if;- C++: aritmetikai kifejezés kell (nem 0: true); csellengő else: legbelső if; blokk kell; pl: if(<expr>) <statm1> [else <statm2>]; if(a<=b) max=b; else max=a; helyett: max= (a<=b)?b:a; - Java: hasonló C++-hoz; kifejezés típusa boolean kell legyen;- Eiffel: végén: end; elsif megengedett; pl: if <expr>1 then <statm>1 {elsif <expr>2 then <statm>2} [else <statm>3] end ;

- esetkiválasztásos elágazás: ált: case expr of const1: st1; const2: st2;… constn: stn end ;sokszor igaz: tetszőleges sorrend; nem feltétlenül egymás után; több is vonatkozhat ugyanarra az alutasításra; - Mi lehet a szelektor típusa?típusa diszkrét kell legyen;- Fel kell-e sorolni a szelektortípus minden lehetséges értékét?kell other ág, hogy minden lehetőséget lefedjünk; - Mi történik, ha fel nem sorolt értéket vesz fel a szelektor?- Rácsorog-e a vezérlés a következő kiválasztási ágra?

- Diszjunktnak kell-e lennie a kiválasztási értékeknek?

- 11 -


mind különböző kell legyen;- Mi állhat a kiválasztási feltételben?Egy érték, értékek felsorolása, intervallum;

- Pascal: szelektor típusa: integer, character, boolean, vagy tetszőleges intervallum típus; else megengedett, de nem kötelező (skip); pl: case var of val1: statm1; val2: statm2;..vali..valj: statmi [else statm] end; pl: var Age: Byte; case Age of 0..13: Write(’Child’); 14..23: Write(’Young’); 24..69: Write(’Adult’); else Write(’Old’); end;- Ada95: others kötelező, ha nincs minden lefedve; .. intervallum, | vagy; pl: case expr is when choice1 => statm1; when choice2=> statm2;… when others=> statms; end case;- C++: default nem kötelező; break kell, ha nem akarod folytatni; pl: switch (intexpr) {case label1: statm1; break; case label2: statm2; break;… default: statm;} Java: mint C++;- Eiffel: nem fordítási időben ellenőriz, ha mégis hiba, akkor exception; változó típusa int, char; pl: inspect var when expr1 then statmblock1 when expr2 then statmblock2…else statmblock end ;- C#: switch (kif) { case ertek1: utasítások.. break; case ertek2: utasítások.. break; …}

Ciklusok: utasítások ismételt végrehajtása valamilyen feltételtől függően;- Vannak-e nem ismert lépésszámú ciklusok?- Van-e elől/hátul tesztelős ciklus?- Kell-e blokkot kijelölni a ciklusmagnak?- Van-e előre ismert lépésszámú ciklus?- A ciklusváltozó mely jellemzője állítható be? alsó, felső érték, lépésszám?- Mi lehet a ciklusváltozó típusa?- Biztosított-e a ciklusmagon belül a ciklusváltózó változtathatatlansága?- Mi a ciklusváltozó hatásköre, definiált-e az értéke kilépéskor?- Van-e általános(végtelen) ciklus?- Léteznek-e a következő vezérlésátadó utasítások? break countine- Van-e ciklusváltozó-iterátor?

Nem ismert lépésszámú ciklusok:- előltesztelő: ált: while <kif> do <utasítás>;- Pascal: ciklusmag egyetlen utasítás lehet, de blokk is; pl: while a<b do b:= b-a;- Ada: végén: end loop; ciklusmag utasítássorozat is lehet; kifejezés boolean típusú; pl: while kifejezés loop ciklusmag end loop ;- C++: ciklusmag egyetlen utasítás lehet, de blokk is; kifejezés aritmetikai értéket ad(nem0: true, 0: false); pl: while (<expr>) <statm>; pl: while (a<b) b=b-a;- Java: hasonló C++-hoz, kivéve: kifejezés boolean; pl: i=0; while (i<10) {System.out.println(i); i++;} ;- Eiffel: ciklusmag utasítássorozat is lehet; végén: end; amíg ciklusfeltétel hamis!; pl: from init [invariant loop-inv variant variant-func] until loop-cond loop loop-body end ; pl: from Result.start until Result.off loop Result.put(item); forth; Result.forth; end

- hátultesztelő: repeat-until; amíg egy feltétel igaz nem lesz; ciklusmag egyszer biztosan lefut; nem kell blokkutasítás; ált: repeat utasítássorozat until ciklusfelt ;

- 12 -


- Pascal: repeat b:= b-a; until (b<=a);- C++: kifejezés aritmetikai érték; pl: do <statm> while (<expr>);- Java: hasonló C++-hoz, kivéve: kifejezés típusa boolean;- Eiffel: until_do;

Előre ismert lépésszámú ciklusok: For-ciklusok:index változó kezelése: lépésköz- határ; - Egyszer ciklusba való belépés előtt értékeli ki a lépésközt és a határt vagy minden végrehajtás után?- A határt a ciklusmag végrehajtása előtt vagy után ellenőrzi?- Mi lehet a ciklusváltozó típusa?- Biztosított-e a ciklusmagon belül a ciklusváltozó változtathatatlansága?- Mi a ciklusváltozó hatásköre, definiált-e értéke kilépéskor?

- Pascal: lépésköz és határ- egyszer; határ ellenőrzése ciklusmag előtt; ciklusváltozó nem változtatható; értéke kilépéskor nem definiált; ciklusváltozó: diszkért típus lehet; pl: for i:=1 to n do sum:=sum+i; pl: for c:=’z’ downto ’a’ do wirte(c);- Ada95: index: ciklus lokális konstansa, diszkrét típusú; ciklus értékintervallumát csak egyszer- belépés előtt számítja ki; reverse..fordított sorrend; pl: for <var> in loop-range loop <utasítások>; end loop; pl: Sum:=0; for I in 1..N loop Sum:= Sum+I; end loop;- C++: for (for-init-stm [expr-1]; [expr-2]) stm; jelentése: {for-init-stm while (expr-1) {stm expr2;} }; pl: sum=0; for (int i=1; i<n; i++) sum=sum+i;- Java: hasonló C++-hoz; Java5.0: for-each ciklus tömbökkel: int[] arrayOfInts={32,87..622}; for (int i : arrayOfInts) { System.out.println(i);}- C#: hasonló C++-hoz; foreach (type identifier in expression) statement;

Végtelen ciklusok:- Ada95: loop <statm>1; … exit when <feltétel>; <statm>2;.. end loop; pl: loop get(Current_Char) exit when Current_Char=’*’; end loop;

Vezérlésátadó utasítások:- break: kiugrás a vezérlési szerkezetből; pl: while feltétel do if speciális-eset then kezeld le; break; end if; kezeld normál eseteket; end while;- countinue: ciklusfeltétel újrakiértékelése;- alprogram hívás;- return:i alprogramból hívóhoz visszatérés;- goto:i veszélyes!;

- C++: break: ciklusban vagy swichtben; countinue: csak ciklusban; return; goto;- Java: nincs goto;

- 13 -


4. Típusok 1. Típusspecifikáció, típusmegvalósítás, típusosztályok, skalár típusosztály típusai a programozási nyelvekben, (példák: Java, C++, Ada)Pointer és referencia típusok, típusok ekvivalenciája (példák: C++, Ada)

Adattípus: értékhalmaz és művelethalmaz; specifikáció- reprezentáció- implementáció; pl: spec: egészek: –Inf,Inf-ig, műveletek: +,-,*- repr: 8,16,32,64-bit, előjeles kettes komplemens kóddal- impl: műveletek megvalósítása; - típusspecifikáció: „mit”; alaphalmaz: valós világ minket érdeklő objektumainak halmaza; specifikációs invariáns (IS)- tovább szűkíti halmazt(pl: egész, IS: páros); típusműveletek specifikációja;- típus megvalósítás: „hogyan”; reprezentációs függvény; típus invariáns; típusműveletek megvalósítása;

ált: - támogatás valamilyen adattípusra; - beépített típusok (spec: kézikönyvben, repr,impl: fordítóprogramban); Mennyire szabványosak a beépített típusok?- vannak megengedett típuskonstrukciók, pl: tömb, rekord;- lehetőség új adattípusok tervezésekor önálló modulokba rejteni repr+impl;

Típusszerkezetek:- Hogyan osztályozhatjuk a típusokat?- Vannak típusosztályok ill rájuk vonatkozó műveletek a nyelvben?Elemi típus: logikailag felbonthatatlan, pl: skalár(diszkrét v valós- fix v lebegőpontos) v mutató; Összetett típus: már meglévő típusokból (mint komponensekből) hozzuk létre, pl: iterált, unió, direktszorzat;

Műveletekre példa:- Ada95: type Hónapok is(Január,Február.., December); automatikusan keletkezik: Hónapok’First, Last, Range, Min(x,y), Value(x);

- 14 -


Típusrendszerek:- Ada95: -- altípus(típus értékhalmazának részhalmaza, összes műveletek alkalmazható rá, pl: Dátum napjai 1..31-ből: napok 1..31) -- származtatott típus(új típus létrehozása már létező típusból, átveszi struktúráját, értékhalmazát, műveleteit, kezdeti értékeit, de nem ekvivalens, pl: type Hossz is new Float); - Java: primitív(logikai és numerikus) és referencia(felhasználó által definiált) típusok;- C#: érték(egyszerű(pl: char, int, float), felsorolás, struct) és referencia(class, interface, tömb) típusok;

A skalár típusok osztálya:diszkrét vagy valós; rendezett értékel, így relációs operátorok(<,>,=) előredefiniáltak;- Ada95: számos attribútum: S’First, Last, Range, Min, Max, Succ, Pred, Image, Width, Value;- Eiffel: ezek mindig kiterjesztett típusok;- C++: „integral” típusok;

- a diszkrét típusok osztálya: - Ada95: minden diszkrét típusú értéknek van pozíciószámra, attribútumai: S’Pos, S’Val;-- felsorolási típusok: explicit megadható, pl: type Days is (Monday,Tuesday,..Sunday); gyakran: karakter és logikai típus is;- Object Pascal: standard fv-ek: Pred(x), Succ(x), Dec(x), Inc(x); logikai: Boolean, ByteBool- 1 byte, WordBool- 2 byte, LongBool- 4 byte; karakter: ANSIChar- 1 byte, WideChar- 2 byte;- Ada95: minden felsorolási literál a felsorolási típus egy önálló típusértéke, van pozíciószáma(elsőnek: 0); rendezési relációt felsorolás sorrendje adja; értékei: azonosító vagy karakter; type Color is (Red ,Blue, Green); logikai: type Boolean is (False, True), műv: lusta kiértékelés(and then, or else); karakter: Character- ISO 10646 BMP(=Basic Multilungual Plane, latin-1), Wide_Character;- C++: enum, kezdőérték: 0; enum color {red, blue, green=20}; logikai: bool (nem0: true, 0: false); karakter: char, signed/unsigned char (nem szabványosítva); - Java: felsorolási típus csak Java5.0-tól; logikai: boolean, érétkei: true, false, műveletei: ==,!=, &&,||, &,|,^(and,or,xor); karakterek: char- 16bites Unicode; - C#: alaptípus: integral(byte, short, int, long); enum(alapértelmezésben int, 0-val kezdődik); logikai: bool; karakter: char- Unicode;

-- egész típusok: nagyon közel a számítógépes reprezentációhoz, szokásos műveleltek;- Object Pascal: ShortInt- signed,8bit, Integer- signed, LongInt- signed,32bit, Byte- unsigned,8bit, Word- unsigned,16bit;- Ada95: root_integerből származik; előjeles egészek: type Page_num is rage 1..2_000; maradékosztályok: type Byte is mod 256; előredefiniált típus: Integer, altípusai: Natural, Positive (subtype Positive is Integer rage 1..Integer’Last); megengedett: Short_Integer, Long_Integer; Short_Short_Integer, de tartalmaznia kell -2**15+4..2**15-1 intervallumot; műveletek: szokásos(+,-,*,/, rem(maradék), mod, abs, **(hatvány));

- 15 -


- C++: előredefiniált egészek mérete: short int, int, long int; a méretek implementáció-függőek; unsigned long/short int modulo 2n aritmetikával használja(nincselőírt specifikáció), műveletek: ==,!=,<,>, +,*,&,%, ++,--, ~(komplemens bitenként);- Java: előírt specifikáció: byte(-128..127), short(-32768..32767), int, long, char(0..65535); - C#: itt is előírt specifikáció; - Eiffel: Integer kiterjesztett; comparable és numeric leszármazottja;

- valós típusok: valós számok közelítései; lebegőpontos: relatív, fixpontos: abszolút pontosság; ált: támogatja előjeles lebegőpontos típusokat: előjelbit mantissa*10exponent, ahol 0<=abs(mantissa9<10); kitevőnek is lehet előjele, jelölés: E; - Pascal: Single(32bit,1+23+8), Real(48bit,1+39+8), Double(64bit,1+52+11), Extended(80bit,1+64+15);- Ada95: lehet fix és lebegő, de csak lebegő van előredefiniálva: Float; root_real-ból származtatott, így literálok universal_real típusúak; megengedett: Short_Float, Long_Float, Short_Short_Float; műveletek: szokásos, +,-,*,/,abs,**; - C++: előre def: float, double, long double; típusok implementáció-függőek, műveletek: szokásos(egyenlő,nem egyenlő, összehasonlítás(==,!=,<,>), indirekció,előjel,cím(*,+,-,&), szor,oszt,modulo(*,/,%), össz,kiv(+,-), növel,csökkent(++,--), léptetés(<<,>>), bitenkénti komplemens(~), feltételes kif(? :), típus mérete(sizeof), tagkiválasztás(->,.), értékadás(=,*=,+=,>>=);- Java: előírt pontosság: float(32bit, alakja: s*m*2e,ahol s= +/-1, m=poz egész kisebb mint 224, e= egész, -149..104), double(64bit, alakja: s*m*2e, ahol s=+/-1, m=poz egész kisebb mint 253, e= egész -1075..970); szabvány a positive_infinity, negative_infinity, NaN(=not a number) is; ha x=NaN, akkor x!=x igaz, mivel semmivel sem egyenlő;- C#: Javahoz hasonló; - Eiffel: kiterjesztett, comparable és numeric leszármazottja;

Pointer és referencia típusok:Olyan objektum, ami megadja egy másik objektum címét a memóriában; értéke: memóriacím; típusos és típus nélküli; segítségükkel magasabb referenciaszinten hivatkozhatunk objektumokra; - hatékonyság: nagy adatszerkezetek mozgatása helyett arra mutató pointert mozgatjuk, probléma: osztott használat; - din adatszerkezetek építésre;- objektumorientált funkciók: polimorfizmus támogatása;

- 16 -


- műveletek:- értékadás: pointerek között; - egyenlőségvizsgálat: ha 2 ugyanolyan típusú pointer ugyanarra az adatszerkezetre mutat; - deferencing: mutatott objektum részére vagy egészére való hivatkozás; - referencing: objektum címe; - allokálás: új objektum, dinamikus;- deallokálás: explicit művelettel vagy implicit (garbage colelctorral);- összeadás, kivonás: megengedett;- csellengő pointerek: kísérlet olyan változó elérésére, ami már nem létezik;

- Csak konkrét típusra mutató pointerek megengedettek vagy vannak típus nélküliek is?- Csak dinamikusan allokált objektumokra mutathat pointer?- Lehet-e alprogramra mutató pointer?- Milyen fajta konstans pointerek megengedettek?- Kötelező a pointer típusoknak önálló nevet adni vagy csak a mutatott típust kell megadni?- Milyen biztonságosan kezelhető a csellengő pointerek problémája?- Mi a megengedett műveletek halmaza?- Kapnak-e pointer változók kezdeti értéket a deklarációnál?- Lehetséges-e ugyanazt az adatot két v több pointeren keresztül is változtatni/elérni?

- Pascal: megengedett típusra mutató és nélküli(Pointer típusú lesz) is; mutathat normál változóra is, pl: var p: pointer, w: word; p:=@w; alprogramra mutathat; műveletek: deference(postfix^), helyfogl(new), dealloc(dispose), értékad(:=), egyenlőség(=); - CLU: nincs hagyományos pointer típus, műveleteket hajt végre objektumokon, változói obj-ra hivatkoznak; immutable(mindig ua értéke), mutable(változhat értéke);- Ada95: nincs típus nélküli pointer, nincs névtelen típusú, mindig kell konkrét típus; mutathat normál változóra is; alrogramra is mutathat; pl: type Int_p is access Integer; default kezdeti érték: null; műveletek: deref(.all), allok(new), értékad(:=), egy(=); felszabadításra nincs explicit eszköz, élettartama a mutató típus hatáskörétől függ; - C++: legtöbb T típusra a megfelelő T* pointer típus, pl: int *p; tömbökre,fv-ekre: int(*vp)[10]; műveletek: deref(prefix*), allok(new), deallok(delete), értékad(=), egy(==), additív(+,-) , incr,decr(++,--), memberof(.*, ->*);; address_of(&.. értékül adjuk változók címét); pl: int i=10; int *pi= &i;- Java: nincs hagyományos pointer típus; változókban 2féle érték: primitív(numerikus v logikai típus) és referencia(osztályok példányai, tömbök); ugyanarra obj-ra számos referencia hivatkozhat; műveletei: mezőelérés, metódushívás, string concatenation, instaceof, ==, !=; - Eiffel: nincs hagyományos pointer típus; kiterjesztett és referencia érték;

- 17 -


5. Típusok 2. Típuskonstrukciók – tömbök, direkt szorzat, unió, halmaz támogatása (példák: Java, C++, Ada, Pascal, CLU)

Adattípus definiálása: pl: Pascal: type<typn>= <value desc>; pl: type myint= integer; Ada95: subtype<typn> is <typl>; type <typn> is nre <typlc>, pl: subtype Int is Integer; type myint is new Integer; C++: typedef<calue desc> <typn>; pl: typedef int myint;

megengedett típuskonstrukciók:iterált (egy kiinduló pontból), direkt szorzat, unió (több kiinduló pontból);

- tömb típusok: azonos típusú elemek sorozata; egy leképezés: folytonos diszkrét intervallumról elemek egy halmazára, nem igazi sorozat típus; -- index (diszkrét intervallum elemei);-- méret (elemek száma int-ban); -- alapművelet: indexelés A[i]; ált… elemek ugyanahhoz a típushoz tartoznak vagy leszármazottai is;

- Milyen adattípusok lehetnek tömb típusok indexei?- Mi lehet tömb típusok elemtípusa?- Tartalmazzák-e a tömb tömb típusok az indexhatárokat? És a tömb objektumok?- Mikor dől el a mérete, helyfoglalása?- Van-e többdimenziós tömb? Van-e altömb (szelet) képzés? Van-e teljes tömbre vonatkozó értékadás (kezdőérték)? Van-e tömbkonstans?- Megválasztható-e egy tömb mérete? Rögzített méretű sorozat vagy nem?

- Pascal: lehet névvel és névtelen tömb típus; index típusa egész, felsorolási v intervallum típus lehet; elemek típusa: tetszőleges; indexhatárt fordítási időben számolja; pl: type <array_type name>= array[i1..j1] of <typen>;- Ada95: rögzített és megszorítás nélküli indexhatárokkal is; pl: type A is array(Integer range 2..10) of Boolean; type Matr is array( Integer range <>, Integer range <>) of Integer; konkrét határokat deklarációnál meg kell adni: M: Matr(1..2,1..4); index típusa: tetszőleges diszkrét típus; elemek: tetszőleges típus; definíciókat futási időben értékeli ki; indexhatárok nem kell statikusak; szeletek is, pl: V(2..8); lehet értékadás azonos típusú tömbök között, pl: V(1..5):= V(2..6); aggregátorral is: V:=(1..3=>1, others=>0);; előredefiniált string típusok: type String is array (Positive range <>) of Characters; type Wide_String is array (Positive range <>) of Wide_Characters; spec attribútumai: A’First, A’Last, A’Range, A’Length; - C++: T x[size] T típusú elemek size méretű tömbje; index 0 és size között; pl: int a[2][5]; kezdeti érték adható; pointer és tömb szoros kapcsolatban (tömbnév mindig tömb 0. elemére hivatkozik); nem tudja méretét; STL tudja???; - Java: objektumok, dinamikusan létrehozva; pl: int [] [] a1, a2; létrehozás: a= new int[20]; mérete: length; kezdeti érték adható, pl: String []colours= {„red”,”white”}; többdimenziós tömbben lehet az elemek mérete különböző; szöveg: String és StringBuffer osztályokkal, de karakterek egy tömbje nem String;

- 18 -


- C#: 0-val kezdődik; adott hosszú v dinamikus; kell példányosítani; lehet többdim; System.Array-ből származik; - Eiffel: Array sablon osztály példánya;

- asszociatív tömbök: elemek rendezetlen halmaza, amelyet megegyező számú kulcs indexel; tárolás: (kulcs, érték) párok;

- Perl: hash skaláris adatok gyűjteménye, %-vel kezdődik; pl: %szinek= (’piros’=>0x00f, ’kék’=>0x0f0); műveletek: keys(kulcsok listája), values, delete(kulcs szerint), each, exists; - C++, Java, Eiffel: szabványos osztálykönyvtárban megtalálható;

Rekord típusok:- ált: direkt szorzat és unió típuskonstrukciókat rekord típusok segítségével valósítják meg;

- Direkt szorzat: ha adott 2 típus S és T, akkor: S x T= {(x,y)|x e s; y e T}; általánosítható: S1xS1x..xSn; rekord mezői: komponensek; alapművelet: komponens kiválasztás; pl: record <name1> : <type1>; <name2> : <type2>; … <namek> : <typek>; end ; nincs rekord: SmallTalk, Eiffel, Java; egyedi: C#, azaz rekord(struct) érték típus, osztály(class) referencia típus; -- diszkriminánsai: típus paramétere; egy típusnak több is lehet; a rekord diszkrimináns diszkrét típusú;

- Lehet-e paramétere a típusnak?- Van-e kezdő értékadás a mezőkre?- Van-e rekord konstans?- Hogyan működik a kiválasztás művelet?

- Pascal: type reknev= record mnev1 : tipus1; … mnev1 : tipus1; end; műveletek: deklarálás(rek: reknev); hivatkozás(rek.mnev1); csak mezőnkénti értékadás; pl: type Date= record Year: Integer; Month: 1..12; Day: 1..31; end; - Ada95: pl: type Complex is record Re: Float; Im: Float; end record; műveletek: változó deklarálása(C: Complex); hivatkozás(C.Re); értékadás(C1:=C2); - C++: struct strnev { tipus1 mnev1;… tipusn mnevn;}; (pontosvessző!!); műveletek: deklarálás(strnev x) hivatkozás(x.mnev1); értékadás megengedett, de egyenlőségvizsgálat nem előre definiált; tömbökre használt jelölés alkalmazható: struct address{ long number; char* street; int zip} address a={1, Vas, 1547};

- 19 -


- Unió és variáns rekord:Variáns rekord: olyan objektumok reprezentációjára, melyeknek van néhány (de nem összes) közös tulajdonsága; van közös része az összes ilyen típusú rekordra, meg ami rekordok egy részhalmazára specifikus; típusértékhalmaz: komponensek típusértékhalmazának uniója; Unió: spec eset, amikor közös rész üres; speciális komponens(tag) és kiválasztási mechanizmus(megadja a tag különböző értékeinek megfelelő alstruktúrát); megkülönböztetett(=discrimianted, ha tag-et tárolja a rekord és alkomponensek elérhetősége ennek aktuális értékétől függ), szabad(=free, különben);; ha szabad, akkor: tag mezők használata opcionális, fordító nem ellenőrzi kiválasztott mező és tárolt érték konzisztenciáját megbízhatatlan típusrendszer; ha megkülönböztetett, akkor: új értéket adni mezőknek- rekord létrehozásakor beállítani tag értékét; program képes legyen új értéket adni a rekord komponenseinek (tag megváltoztatása a rekord szerkezetének megváltoztatását vonja maga után);

-- Unió: case <tag-name> : <tag-type> of <cosnt1> : (<fields1>); <cosnt2> : (<fields2>); … <cosntv> : (<fieldsv>); nincs: SmallTalk, Eiffel, Java, C#; helyette osztályok és öröklődés használata; - Meg lehet-e állapítani, hogy a rekord melyik változat szerint lett kikötve?- Ki lehet-e olvasni a kitöltéstől eltérő változat szerint?- C++: union typname{ typ1 field1;…typm fieldm; };

-- Halmaz: - Mi lehet az eleme?- Hány eleme lehet?- Megvannak-e a hagyományos halmazműveletek?- Pascal: alaphalmaz: diszkrét típus; elemek száma: max 256; értékek sorszáma: 0..255; pl: type Small_Letters= set of ’a’..’z’; type Day={Monday,…} type Days= set of Day; var A,B : Days; A:=[Monday, Wednesday]; - halmazkonstruktor; műveletek: értékadás, halmazműv(eleme(in), részhalmaz reláció(<=, >=), <,> nem lehet!, unió, differencia, metszet(+,-,*) ez a precedenciasorrend);

Típusok ekvivalenciája:- strukturális: - A rekordok mezőnevei is figyelembe vannak véve vagy csak a struktúrájuk?- Számít-e a rekordmezők sorrendje?- Tömböknél elég-e az indexek számosságának egyenlőnek lenni vagy indexhatároknak is egyezniük kell?- név szerinti:- Deklarálhatók-e egy típushoz típusok, amelyekkel ekvivalens?- Névtelen tömb ill rekordtípusok ekvivalensek-e valamivel?

Típuskonverziók: Van-e és hogyan működik? Automatikus? Identitás? Bővítő? Szűkítő? toSting konverzió?

- 20 -


6. Absztrakt adattípusok a programozási nyelvekben Procedurális- és adatabsztrakciós megközelítés, elvárások és eszközök (példák: Java, C++, Ada)

Absztrakció: gondolkodásmód- ált elvekre koncentrálok; feladat lényeges aspektusai, eltekinteni a kevéssé lényegestől; tervezés központi kérdése, hogy rendszer felépítését mire alapozzuk?

- Saját adattípus önálló fordítási egységként megvalósítható?- Specifikáció és implementáció különválasztható?- Reprezentáció elrejtése megvalósítható?- Milyen láthatósági szintek vannak?- Van-e azonosító/ operátor túlterhelés/ free operátor?- Beépített típusokkal megegyező módon használható?

- proceduális absztrakció: top-down; végrehajtandó tevékenységekre; mivel egy alprogram specifikáció a magasabb szintű specifikációtól függ, így a változás tovább gyűrűzik lefelé és végül egy egész kis változósnak nagyon nagy hatása lehet;

- adatabsztrakció: bottom-up; ha elég magas szinten analizáljuk a problémát, akkor a rendszerek jobban jellemezhetőek hosszú távon objektumaikkal, mint a rájuk alkalmazott tevékenységekkel; először: jellemezni objektumokat és osztályaikat(adattípusokat), amelyek szerepet játszanak a rendszerben; új adattípusokat a már meglévők felhasználásával tervezzük (elérhető komponensek szintjétől indulunk, abból építkezünk);

Adattípus: értékhalmaz és művelethalmaz; specifikáció- reprezentáció- implementáció; pl: spec: egészek: –Inf,Inf-ig, műveletek: +,-,*- repr: 8,16,32,64-bit, előjeles kettes komplemens kóddal- impl: műveletek megvalósítása;

- típusspecifikáció: „mit”; alaphalmaz: valós világ minket érdeklő objektumainak halmaza; specifikációs invariáns (IS)- tovább szűkíti halmazt(pl: egész, IS: páros); típusműveletek specifikációja;- típus megvalósítás: „hogyan”; reprezentációs függvény; típus invariáns; típusműveletek megvalósítása;

- 21 -


Elvárások a programozási nyelvekkel szemben:- modularitás: egyes típusokat önálló fordítási egységekben lehessen megvalósítani; biztosítja a típusok újrafelhasználhatóságát, hatékony programfejlesztést (egyes modulok könnyen átvihetőek más programokba, különböző egységeket más-más programozó is fejleszthet); - adatrejtés: reprezentáció elrejtése; nyelv maga biztosítja, hogy az adott típus használója csak a specifikációban megadott tulajdonságokat használhassa ki; meg lehet változatni a reprezentációt, ill implementációt anélkül, hogy a programban felfelé gyűrűzne;- specifikáció és implementáció szétválasztása külön fordítási egységekbe: adott típust használó más modulok a típus specifikáció birtokában elkészíthetőek (függetlenül a tényleges implementációtól);- modulfüggőség kezelése: fordító program kezelje maga a modulok közötti relációkat (egyik használja a másikat);- konzisztens használhatóság: felhasználói és beépített típusok ne különbözzenek a használat szempontjából; típusokat minél inkább a valós világban megszokott természetes módon lehessen kezelni;- generikus programsémák támogatása: megadni a lehetőséget a programozónak minél általánosabban írhassa meg programjait; lehetőség ismétlések minimalizására (nem csak közvetlen kódismétlések elkerülése, hanem magasabb szintű megoldási struktúrák többszörös megírásának elkerülésére); javítja kód olvashatóságát, karbantarthatóságát;

Absztrakt típusok megvalósításának eszközei:- modulokra bontás: alapja: típusokra bontás, azaz egy modul egy típust implementál; de csak kevés nyelv alapul tejesen erre, így szükség van alprogram könyvárakra ill csak implementációs célokat szolgáló típusok megvalósítására (ezeket lehetőség szerint azt használó adattípus moduljába rejtjük el; - reprezentáció elrejtése: összetett típusok komponenseinek láthatóságát szintekre bontja (kik férnek hozzá); leggyakrabban: nyilvános(=public, adott komponens mindenki számára látahtó), védett(=protected, csak leszármazottak számára), pirvát(=private, teljesen rejtett, csak műveletek implementációjában használható komponensek); egyen nyelvekben nincs ilyen szabályozás, vagy még finomabban szabályozható(pl: Eiffel, mely osztály és leszármazottai férhetnek hozzá adott komponenshez); pl: Class A feature {B,C} X: Integer; feature{ANY} … feature{NONE} end ;- specifikáció és implementáció szétválasztása: amelyik nyelv támogatja az „egy modul egy típus” elvet, ott gyakran lehetőség van a típusspecifikáció implementációtól külön, önálló fordítási egységben történő leírására (egyes modulok egymástól függetlenül elkészíthetőek, továbbá: repr és imp észrevétlen megváltoztatása); reprezentáció elrejtése sajnos teljes egészében nem lehetséges (használó modul számára nem tanácsos az ismerete, de fordítóprogramnak tisztában kell lennie azzal, hogy mennyi memóriát kell az adott típusú objektum számára lefoglalni); ezért kell gondoskodni: specifikációs rész birtokában képes legyen szükséges memóriafoglalást meghatározni (mutató v ref);

- 22 -


- Ada: más megközelítés; spec és repr került egy fordítási egységben, így repr nincs fizikailag elrejtve, de szintaktikus eszközökkel gondoskodik róla, hogy a típust felhasználó másik programegység ne tudja kihasználni; - C,C++: specifikációt fizikailag be kell másolni minden olyan fordítási egységbe, amely adott típust használni akarja- nem igazi szétválasztás (specifikáció egy külön forrásfájlban(header) leírható, előfordító segítségével beemeljük a megfelelő fordítási egységekbe; ha többször írjuk be, az hiba, kivédése: programozónak kell úgy megírnia headert); - Java, C#: spec és impl összemosódik, segítség: dokumentációval előállítani specifikáció szöveges leírását;- Eiffel: fizikai szétválasztás lehetetlen, itt a fejlesztő eszköz támogatja a kód többszintű nézetét (felhasználó szempontjából lényegtelen részek eltakarhatóak);

- modulfüggőség kelezése: program működése modulok interakciója; minden modul igényel szolgáltatásokat és segítségével más szolgáltatásokat valósít meg- függőségi reláció (egy modul megváltoztatása- tőle függő modulok újrafordítása); - C,C++: teljesen programozóra bízza függőségek kezelését, minden fordítási egységet önállóan kezel, ezért speciális eszközök(pl: make) feladat megkönnyítésére- nem tökéletesek (túl sokszor újrafordít v nem veszi észre);- más nyelvek: függőségek kezelése a fordító feladata; pl: Ada: milyen más fordítási egységektől függ az adott modul (with)- garantálja, hogy minden adott modultól függő modul lefordításra kerül;

- konzisztens használat: ne tegyen különbséget beépített és programozó által definiált típusok között- új típust be lehessen illeszteni nyelv logikájába; pl: beolvasás (read) művelettel, akkor saját típusomhoz is definiálhassak read műveletet, azaz lehetőség azonosító túlterhelésére(=átlapolására= overloading; programszöveg egy adott pontján azonosítónak több definíciója is érvényben van); operátor túlterhelés: felhasználói típusokat természetes használatuknak megfelelően használhassuk;

- 23 -


7. Alprogramok Eljárások és függvények, paraméterátadás-átvételi módok, túlterhelés, rekurzió (példák: Java, C++, Ada)

Absztrakció: gondolkodásmód- ált elvekre koncentrálok (filo, mat, számítástudomány); feladat lényeges aspektusai, eltekinteni a kevéssé lényegestől (pl: légiközlekedés: lényeges: helyzet, seb, lényegtelen: szín ,utasok neve); - programozásban: lényeges: Mit csinál a program?; lényegtelen: Hogyan van implementálva?; minden programozási nyelv a gépi kód absztrakciója; -- magasabb szintű absztrakció: eljárás: Mit csinál az eljárás?; eljárást hívó eljárások: akárhány szükséges szintje bevezethető; - absztrakciós mechanizmus: megragadni absztrakciót- nyelvi konstrukció engedi meg, program részeként reprezentálja (számítási mintaként); pl: eljárások és fv-ek (egységek, melyek számításokat tartalmaznak);-- amikor absztrakciót hívunk, akkor a tartalmazott számítás mindig végre lesz hajtva; -- érdekeltségek szétválasztása: implementáció (hogyan kell számítást végrehajtani), Hívó (mit csinál a számítás);-- hatékonyság: paraméterezéssel javítható;

Absztrakciós elv:Tetszőleges szintaktikai osztály fölött létrehozhatunk absztrakciókat (feltéve, hogy ez valamifajta számítást specifikál)- absztrakt adattípusok, generic; Függvény-absztrakció: kifejezés absztrakciója; egy kiszámítandó kifejezést tartalmaz; amikor hívjuk, egy értéket ad vissza; pl: Ada: function Keruler (R: Float) return Float is begin return R*R*3.14; end;- végrehajtás: kifejezés értékének meghatározása; neve: fn v mn;- függvény definíció: function I (FP1;..;FPn) return T is E; I azonosítót hozzákapcsol egy adott függvény absztrakcióhoz; megfelelő paraméterekkel való híváskor eredményt ad vissza; fvhívás: -- felhasználói szemlélet: egy leképezés argumentumok és eredmény között;-- megvalósítói szemlélet: függvénytörzs kiértékelése (algoritmus változása csak megvalósítóra tartozik); pl: function Faktoriális (N: Natural) return Positive is Fakt: Positive:= 1; begin for I in 1..N loop Fakt:=Fakt*I; end loop; return Fakt; end Faktoriális;

Eljárás-absztrakció: parancs absztrakciója; egy végrehajtandó parancsot tartalmaz, ami frissítheti a változók értékét- felhasználó csak a változók megváltozását érzékeli; ált: nem lehet név nélkül létrehozni, formátuma: procedure I (FP1;..;FPn) B B..body;- végrehajtás: utasítás; neve: ige; -- felhasználói szemlélet: pl: type Dictionary= array[..] of Word; procedure sort(var words: Dicitionary);… sort(a); - érzékeljük változást;-- megvalósítói szemlélet: kódolt algoritmus; pl: procedure Cserél (A,B: in out Integer) is Temp: Integer:= A; begin A:=B; B=:Temp; end Cserél;

- 24 -


Alprogram: - használata egyik legelső programozási eszköz; Charles Babbage 1840-ben tervezte lyukkártyákkal; - segítésével nevet adhatunk egy kódrészletnek és paraméterezhetjük viselkedését;- programegység;- végrehajtás kezdeményezése meghívással;- különböző számítások elkülönítése egymástól;- újrafelhasználhatóság; - beágyazható sok progrnyelvben: blokkszerűen, deklarációs részbe(lokális, globális), hatáskör, láthatóság, élettartam;

Mire való? Nagyobb feladat részfeladatának megoldására; algoritmus kódolása; típusműveletek megvalósítása; matematikai függvény kiszámítása;

alprogram= (név, paraméterek, környezet, törzs);- formális paraméter: definíciókor ezzel írjuk le adatcsere elemeit;- aktuális paraméter: használatkor ezek kerülnek formálisak helyébe paraméterátadás; pl: val Pi= 3.14; val r=1.0; fun perimeter(R: real)= 2*pi*r; - formális; perimeter(0.1); perimeter(a+b); - aktuális parméter;

Paraméterek:- információ átadása/átvétele alprogramhívásnál: paramétereken v visszatérési értékeken keresztül;- alprogram hívásakor: formális paramétereknek aktuálisat feleltetjük meg;- paramétereknél: információ áramlása: -- merre (infoáramlás iránya): input: hívó alprogram; output: hívó alprogram; update: hívó alprogram;-- hogyan (paraméterátadás technikája, módja): - érték szerint: -- formális paraméter az alprogram egy lokális változója, aminek aktuális paraméter adja kezdőértéket; -- akt paraméter kiértékelésére egyszer, alprogram végrehajtásának megkezdése előtt kerül sor; -- alprogram végrehajtása közben: sem akt értékének megváltozása aktre, sem form értékének megváltozása nincs hatással aktre; -- pl: C-ben: int lko(int a, int b) { while (a!=b) if (a>b) a-=b; else b-=a; return a; } int x=10; y=5; y= lnko(x,x+y+1) x marad , y 2 lesz;

- 25 -


- cím szerint: -- akt: változó vagy változó komponensét meghatározó kifejezés(pl: x[i]); -- akt kiértékelése: alprogram végrehajtásának megkezdése előtt; akt memóriacímerendelődik hozzá;-- közben: hivatkozhatunk form értékére, új értéket is adhatunk; -- pl: Pascalban: procedure Csere(var a,b: Integer); var temp: Integer; begin temp:=a; a:=b; b:=temp; end; x:=3; y:=6; Csere(x,y); x=6; y=3;

- eredmény szerint:-- kimenő paraméterek megvalósításához; alprogram form-ben kiszámított eredményt helyezi vissza aktba;-- form alprogram lokális változója, melynek értéke alprogram befejezésekor kimásolódik aktba;-- akt: balérték kell legyen; -- form nem kapja meg akt értékét alprogram hívásakor, ezért egyirányú infóáramlás; -- pl: Adaban: procedure Get( Item: out Character);

- érték/eredmény szerint:-- alprogram befejezésének pillanatáig megegyezik érték szerinti paraméterátadással;-- alprogram végrehajtásának befejezésekor: akt felveszi form pillanatnyi értékét;-- akt: csak balérték lehet; -- pl: procedure Parcsere(X,Y: in out Integer) is Temp: Integer; begin Temp:=X; X:=Y; Y:=Temp; A:=12; B:=99; end; A:=1; B:=2; Parcsere(A,B); A=2; B=1;

- név szerint: -- akt paraméterként leírt teljes kifejezés adódik át;-- minden használatkor kiértékelődik, pl: a[i]értéke változhat, ha i változik közben;-- pl: program I: integer; A: integer array; Swap_by_name: procedure(X: name, Y: name) temp: Integer; begin temp:=X; X:=Y; Y:=temp; end; begin I:=3; A[I]:=6; output I,A[3]; Swap_by_name(I,A[I]); output I,A[3]; end; kimeneten: I=3 A[3]=6 I=6; A[3]=6, de A[6]=3 lesz!;

alprogram paramétereinek száma: - ált kötött, de lehet változó is (tömb átadásával szimulálható, de nem mindig oldható meg eltérő típusok paraméterátadása);- túl sok(elhagy) v túl kevés(alapértelmezett érték pozíció vagy név szerint; vessző kihagyott paraméterek helyett; amíg nincs alapértelmezett, addig kötelező akt megadni- alapért paraméterlista végén) paraméter megadásának kezelése;

- 26 -


Paraméterek megfeleltetése: procedure Get_line (File: in Fily_Type; Item: out String; Last: out Natural); - pozícionális formában: akt abban sorrendben, ahogy form vált alprogram specifikációjában; pl: Get_line(F,S,N);- névvel jelölt formában: paraméterek sorrendje tetsz; pl: Get_line(File=>F, Last=>L, Item=>S);- kevert formában: mindig pozícionálisan megadott paraméterek elől; pl: Get_line(F,Last=>L, Item=>S);

Paraméterek feltételezett értéke:- in módú paraméterkhez feltételezett bemenő értéket rendelhetünk hozzá; alprogram specifikációs része tartalmazza ezt a feltételezett értéket- felveszi form, a akt-ot nem adunk meg;- pl: procedure Nex_line(File in File_Type; Spacing in Positive_Count:=1); ezt hívhatjuk: New_line(F) – 1 sort emel; New-Line(F,4) – 4 sort emel;

Alprogramok túlterhelése (átlapolása):- azonos név, paraméterek száma és/vagy típusa különböző; használatból derül ki, melyikre gondolunk; - pl: procedure Cserél(A,B: in out Integer); procedure Cserél(A,B: in out Boolean);- mellékhatás: újrafelhasználhatóság, karbantarthatóság;- kerülni: globális változók használatát; függvény paraméter is változik; pl: void main() { int i,j=1; int k; k=f(i,j); }

Operátorok:- műveletek infix alakban is írhatóak: A+42 vagy +(A,42);- átlapolhatók; pl: function „+” (A,B: Mátrix) return Mátrix;

Rekurzió:- közvetlenül vagy közvetve önmagát hívó alprogram; - paraméterátadás szempontjából nem különbözik szokásos alprogramoktól- ezért cím szerint átadni elővigyázatosan, mert sorozatos hívások interferálhatnak; - pl: function Faktoriális (N: Natural) return Positive is begin if N>1 then return N*Faktoriális(N-1); else return 1; end if; end Faktoriális;

- Van-e eljárás? Van-e függvény?- Mely paraméterátadási módok léteznek?- Meghatározható-e a paraméterek információátadásának iránya?- Adható-e a formális paramétereknek alapértelmezett érték?- Túlterhelhetőek-e az alprogramok?- Operátorok átlapolhatók-e?- Definiálhatóak-e új operátorok?- Típus-e az alprogram? Lehet-e alprogrammal paraméterezni?

- 27 -


- Algol68: érték szerinti az alapértelmezés; cím szerint (ref); nincs név, eredmény szerint; van operátor átdefiniálás;- Pascal: érték szerinti az alapértelmezés; cím szerint (var); pl: program A procedute Szoroz(Var Mit: Integer; Mivel: Integer); begin Mit:= Mit*Mivel; end; Var N,K: Integer; begin N:=5; K:= 3; Szoroz(N,4); Szoroz(N,K); Szoroz(5,N); end ; N=20; N=60, K=3; hiba!; - C,C++: csak függvény van, ha nem: void visszatérési érték; csak érték szerinti paraméterátadás; cím szerint: mutató v referencia kell; lehet paramétereknek kezdőértéket adni; pl: void f(int val, int& ref) { val++; ref++; } void g() { int i,j=1; f(i,j); } i=1, j=2 lesz; const& paraméter- nem változtatható törzsön belül; tömb: első elemére hivatkozó mutató adódik át(nem érték szerint), mérete nem; túlterhelés lehetséges; pl: void print(int), void print(char); - Java: csak valamely osztály metódusa lehet; aktuális objektum paramétereire hivatkozik; paraméterátadás: primitív típus(érték szerint), összetett típus(referencia szerint); - Smalltalk: üzenetküldésekkel érjük el metódusokat; érték szerint (referenciák figyelembevételvel);- Ada: in, out, in out; összetett típus esetén fordítóprogram választ érték-eredmény, ill cím szerinti átadás között; fv: csak in paramétere lehet (ezeknek lehet alapértelmezett értéke); - Eiffel: nem lehet azonos neve; csak pozícioálisan lehet megadni, nincsenek alapért értékek; argumentumszám változása tömb segítségével; paraméterek értékét rutinok nem változtathatják meg (ha ref: obj állapotát megváltoztathatja, de referenciát nem állíthatja máshova);

- 28 -


8. A kivételkezelés Alapfogalmai, kivételek kiváltása, terjedése, kezelése, specifikálása, kivételosztályok (példák: Java, C++, Eiffel)

Cél: jó minőségű programok; program lf tul: helyes (spec-nak megfelelően működik), robosztus (nem várt helyzetekben sincs katasztrófa) figyelni kell hibákra és meg kell próbálni megelőzni vagy ha már bekövetkeztek, kezelni őket;

Hibalehetőségek: programok futása közben léphetnek fel;- szoftverhibák: futtatott programban (0-val osztás, túl/alulcsordulás, üres pointer dereferencia, tömb hibás indexelése, hibás típuskonverzió, hibás input), operendszerben programozói hibák; - hardverhibák: elromlott winchester, elfogyott memória;

Hibakezelés:- régebben: abortált a program; minden alprogram valamilyen jelzést (hibaértéket) ad vissza, hogy lefutás jó vagy nem- nem tudjuk hol volt a baj és bonyolult; pl: ReadFile(f: in File; n1: out byte; n2: out integer; n3: out longint): boolean; success: boolean; begin success:=ReadByte(f,n1); if success then success:=ReadInt(f,n2); if success then success:= ReadLongint(f,n3); if not success then ReadLongint hiba kezelése end if; else ReadInt hiba kezelése end if; else Readbyte hiba kezelése end if; return success; end ReadFile; - meggondolások: -- nem biztos, hogy függvényt lehet/érdemes csinálni eljárásból paraméter jelzi a sikert (de ha több szálon fut, akkor ki írt bele utoljára?);-- kód sokkal bonyolultabb- nehéz karbantartás;-- nem biztos, hogy a hívó figyeli sikert jelző értéket; -- lehetne globális változót használni, de mi van osztott környezetben?-- hibakezelő alprogramot meghívni;

- elvárások:-- hibák megkülönböztetése; -- hibakezelő kód különüljön el tényleges kódtól- könnyen karbantartható;-- hibát megfelelően kezelje- jusson el oda, ahol kezelni kell (alacsonyabb szinten jelentkező hibát nem biztos, hogy adott szint le tud kezelni);-- kötelező legyen kezelni hibákat kivételkezelés;

- megoldások:-- megkülönböztetés: ált fellépés helyén;-- elkülönülés: pl: class AlmaException extends Exception{} class KorteException extends Exception{} class BarackException extends Exception{} gyumolcs { try{ alma(); korte(); barack(); } catch(AlmaException e1) { 1.hiba kezelése } catch(KorteException e2) { 2. hiba kezeléese } catch(BarackException e3) { 3. hiba kezelése} }

- 29 -


-- eljutás: pl: gyumolcs { alma(); //folyt1} alma { jonatan(); //folyt2} jonatan { //műveletek } gyumolcs{ try{ alma(); //folyt } catch(VmiExc) { //hiba kezelése } } jonatan throws VmiExc { //műveletek } alma throws VmiExc { … jonatan(); //folyt }

- Hiba vagy kivételkezelést ad a nyelv?- Hogyan kell kivételeket definiálni, kiváltani, kezelni? (szintaktika, lehet-e kivételcsoportot, kivételosztályt képezni)Kiváltás: throw, raise, Kezelés: catch, except; Kivételosztály: Java,C++ lehet;- Van-e előre definiált kivétel? Javaban sok;- Paraméterezhető-e a kivétel információ továbbadása céljából?Kivétel obj, aminek létezik belső állapota;- Támogatja-e a nyelv explicit módon valamilyen végső tevékenység (finally) megadását? Ha nem, akkor tudjuk szimulálni? Milyen megszorításokkal?- A nyelv biztosít-e olyan nyelvi konstrukciót, amelynek nem kell explicit módon megadni, hogy mely kivételt kell továbbadni?- Újrakezdhető-e alprogram a hiba kezelése után? Retry; - Megadható-e/meg kell-e adni, hogy egy alprogram milyen lekezeletlen kivételeket küldhet?C++: opcionális; Java: kötelező; - Párhuzamos környezetben vannak-e speciális kivételek?- Kiváltható-e kivétel a kivételkezelőben?- Melyik kivételkezelő kezeli a kivételt?

Hiba: normál végrehajtást felfüggeszt; - hibakezelő nyelv: a hiba az hiba;Kivétel: vezérlés átadódik a legközelebbi megfelelő hibakezelő résznek; objektum, aminek tetszőleges a típusa; nem hiba- kívülről nem észlelhető; - kivételkezelő nyelv: lekezeli, lokálisan megoldja problémát;- pl: type Napok is (Vasarnap,Hetfo,..,Szombat); function Holnap(Ma: Napok) return Napok is begin return Napok’Succ(Ma); exception when Constraint_Error=> return Napok’First; end Holnap;

- C++: predefinit kivétel: bad_cast (ha dynamic_cast nem hasznáható), bad_typeid (ha operátora null pointer dereferenciája); -- kivétel kiváltása: throw [expression]; - normál program megszakad, vezérlés legközelebbi megfelelő kezelőhöz kerül; ha nincs kifejezés, akkor aktuális kivétel újraaktiválása; (csak kivételkezelőben lehet); pl: throw 5; throw „hiba”; további információ kivételosztályokban; pl: class ExceptionWithParameters { public: int a,b; ExceptionWithParameters(int a0, int b0) { a=a0; b=a0; } }; //… throw ExceptionWithParamters(0,1); -- kivételek kezelése: try blokkal; a dobott kivételeknek megfelel egy catch ág, ha valamelyik felt teljesül: 2 típus ua; catch ág típusa publikus bázisosztálya az eldobott objektumnak; catch ág típusa mutató, eldobott obj mutató, amit át lehet konvertálni catch ág típusára;; kezeletlen kivételek: továbbgyűrűzik hívó try blokkjába, majd legkülső ty blokk után terminate fv kerül meghívásra; pl: class A{}; class B: public A{}; class C: public B{};

- 30 -


… catch(A) – mindent elkap; catch (const B&) – B és C; catch(void*) – tetszőleges pointer típust kap el;; ha: catch(A){…} catch(B){..} – soha nem lép B-be;terminate hívása abort-ot jelent, de set_termiante-tel megadható más (azért le kell állítsa programot); vezértlés átadódik kivételkezelőnek, destruktort hív minden objektumra, ami try-blokkban keletkezett; -- kivétel specifikáció: throw „(„ [type {„,” type}] „)” ,pl: void f(int x) throw(A,B,C) – f fv A,B,C típusú kivételt generál; ha specifikáltunk kivételtípusokat, akkor minden más esetben rendszer meghívja unexpected() fv-t, mely alapértelmezésként terimate() fv- hívja meg; pl: class X{}; class Y: public X{}; class Z{}; void A() throw(X,Z) {…} – X,Y,Z-t dobhat; void B() throw(Y,Z) {A(); } – Y,Z-re jó, ha X, akkor unexpected; void C(); - semmit ne mtudunk róla; void D() throw(){ C(); throw 7;} – bármit kivált unexpectedet hív;

- Java: hasonló C++-hoz; -- eltérés: szemantikában: finally; pl: try{… throw new EgyException(„parameter”); } catch(típus változónév){…} finally{...}; -- függvény specifikálása: void f(int x) throws EgyikException, MasikException;-- ha egy szálon fut: Vm és program is terminál; ha több szálon: uncaughtException() fut le; -- minden kivétel: java.lang.Throwable leszármazottja; csoportjai: ellenőrzött: Exception leszármazottjai (fordítási hiba lép fel, ha nincs elkapva); nem ellenőrzött: Error leszármazottai (előre nem látható, fölösleges mindenhol lekezelni, pl: van-e elég memória); de nem konzisztens: Exception egyik osztálya: RunTimeException ugyancsak nem ellenőrzött; -- predefinit: RuntimeException leszármazottai: ClassCastException, IndexOutOfBoundssException, NullPointerException; Error leszármazottai: OutOfMemoryException, StackOverflowError; pl: void Y() { int ia[]= new int[10]; for (int i=1; i<=10; i++) ia[i]=0; }- amikor i=10 lesz, akkor ArrayIndexOutOfBoundsException; void Z() { C.c= null; c.X(); }- NullPointerException; - kivételek kezelése: try{ //utasítások } catch(MyException e{ //kezelés} catch(AnotherException e) { //kezelés} finally { //mindig végrehajtódik} pl: class ExcA extends Exception{} void A() throws ExcA{ … throw new ExcA();…} void B1() { A(); } – fordítási hiba, ExcA nincs lekezelve; void B2() { try{ A(); } catch(ExcA e){ //kezelése}} class ExcF extends ExcA{} void F() throws ExcA{ throw new ExcF(); } – jó, mert ExcF leszármazottja ExcA-nak;

- Ada: blokkszintű védelemt nyújt; blokk végén: excpetion (when ágakban felsoroljuk kezelni kívánt kivételeket); kivételek nem paraméterezhetőek; nincs finally (de ha olya nwhen ág, ahonan kivétel nem gyűrűzik tovább, akkor úgy viselkedik); előre definiált: Constraint_Error, Program_Error, Storage_Error…; saját kivételek:; kiváltás: raise; kezelés: begin ut1; exception when Name_error=> Put_Line(„Hibás fájlnév”); when End_Error | Hibás_Formátum=> Close(befájl); end;

- Eiffel: mindig tárolja obj belépéskori állapotát;

- 31 -


-- úrjakezdés: ha kompomens írásakor egy kivétel lehetőségét lehet látni, akkor alternatív megoldás találni (így betartva szerződést); pl: try_once_or_twice is local already_tried: bolean do if not already_tried then method1 else method2 end rescue if not already_tried then already_tried:=true; retry end end ;-- szervezett pánik: ha nincs rá mód, hogy teljesítsük a szerződést, akkor objektumokat elfogadható állapotba kell hozni (típusinvariáns helyreállítása), és a felhasználónak jelezni kell a kudracot; pl: transaction(arg: context) is require … do … ensure … rescue reset(arg) end ;- C#,.NET: hasonló Java-hoz (try-catch blokk, finally), de nincs exception-specifikáció, ellenőrzött kivétel (nem szigorú szabály kell, ahenm elemző eszközök, amik felkutatják);

- 32 -


9. Sablonok Típussal, alprogrammal való paraméterezés, példányosítás, sablon-szerződés modell (példák: Java, C++, Ada, Eiffel)

Cél: újrafelhasználható, könnyen karbantartható programok; ezért minél általánosabb típusok és alprogramok, hogy a legszélesebb körben használhassa; programozási módszertan is általánosan használható megoldásokat tanít- ezt progrnyelvek többé-kevésbé támogatják; Mitől újrafelhasznáható? - alprogramok;- alprogramok paraméterezése;- típusok paraméterezése;- alprogrammal történő paraméterezés; - típusokkal történő paraméterezés (implementációt 1x megadni- általánosan, az összes feltételt kielégítő típussal használni); pl: halmaz típus (típusértékhalmaz, műveletek), milyen elemek halmaza? Egészek, diákok, autók? – tervezzük meg az elemek típusától függetlenül ill példányosítsuk a konkrét használatkor; szerződés: sablon törzssablon specifikáció példányosítás;

- Milyen nyelvi elemekből tudunk sablonokat létrehozni? (új adattípus és/vagy alprogram)- Milyen paraméterei lehetnek? Létrehozható-e paraméter nélküli sablon?- Milyen fajta típusok lehetnek aktuális típusparaméterek? (beépített vagy felhasználó által definiált is)- Adhatunk-e megszorításokat a formális generic paramétereknél?- Egymásba ágyazható?- A példányosítás fordítási(stat) vagy futási(din) időben történik?

Eszközök:- C: nincs nyelvi szinten, de hasonló hatások elérhetőek (előfeldolgozó rendszer használatával, ami nem nyelvi eszköz, mert porrásnyelvű programot manipulálja); - objorientált progrnyelv: hatás elvielg elérhető öröklődés és polimorfizmus használatával- összes tulajdonságot össze lehetne fogni egyetlen absztrakt osztályba, amely közös őse lehene összes feltételnek eleget tevő osztálynak; hiba: (előre) nyelv osztályhierarchiájának kialakításakor ismrni kellene az összes számíttásban jövő feltételkombinációt; - típussal paraméterezést támogató nyelvek: önálló konstrukciót vezetnek be (megadhatunk fromális paraméterként típusokat, amiket más típusokhoz hasonlóan használhatunk);- példányosítás: amikor formális paramétereknek aktuális értékeket adva létrehozzuk a struktúra emgadott típushoz tartozó változatát;

- C++: típussal paraméterezés lehetősége: template;

- 33 -


-- több, mint makróhelyettesítés (ahol fordító a megadott aktuális típussal helyettesíti a hozzá tartozó formális paraméter minden előfordulását); -- minimális szintaxisellenőtzés, de formális paraméternél csak annyit tudok meghatározni, hogy adott paraméter egy típust jelöl;-- nem tudom előírni a megvalósítandó alprogram v típus számára fontos tul (pl: műveletek) meglétét- ebből származó hibák példányosításkor jelentkeznek;-- előny: példányosítás teljesen automatikusan történik; -- pl: template <typename T> void swap(T& x, T& y) { T temp=x; x=y; y=temp; } vagy template <class T> T max(T x, T y){ return (x>y) ? x : y; } ennek használata: int i; Own_Typ a,b; int j=max(0,i); Own_Typ m= max(a,b); double x,y= 5,1; z= 3,14; int i=3,j=4,k; x= max(y,z); k=max(i.j); z=max(i,x) – ambigous, no standard conversion; megoldás: explicit specializáció: template <class R, class T, class S> R max(T a, S b) { if (a>b) return a; else return b; } z=max<double>(i,x); - ok: 3,14; k= max<long,long,int>(i,x) – konvertál; k= max<int,int,int>(i,j) – fölösleges;

- Eiffel: generic;-- erősen objektumorientált megközelítés;-- formális paraméterei: osztályok lehetnek, ahol a szükséges speciális tul-okat azáltal lehet meghatározni, hogy megadható, mely osztályból kell származnia aktuális paraméternek; -- előny: belsejében használt műveletek a megadott ősosztály műveletei lehetnek, így használat helyessége megíráskor ellenőrizhető;-- hátrány: szükséges közös tul-okat jóval előre tudni kell, hogy megfelelő közös ős definiálható legyen; ekkor viszont a problémák jórészt megoldhatóak öröklődés és polimorfizmus segítségével; -- megszorítás nélküli generic: class Linked_list[G], class Array[G]; osztályoknak akárhány formális generic parmétere lehet; minden formális paraméterhez kell egy típus (az aktuákis generic paraméter)generikusan származtatott (példányosított) típust eredményez; -- példányosítás: Tree[Integer], Tree[Paragraph], Linked_list[Paragraph], Tree[Tree[Tree[Paragraph]]], Array[Linked_list[Tree[Linked_list[Paragraph]]] ;-- korlátozott generic: ált szintaxis: T->Class-type; pl: class Hash table[G, Key->Hashable] – key-t megszorítjuk Hashable osztállyal (ennek leszármazottja kell legyen);

- Ada95: sablonok paraméterezhetősége sokkal szélesebb körű és rugalmasabb a korábbiaknál; lehet:-- megadott őstípusból származó típussal paraméterezni;-- kiköthető, hogy akt paraméter valamilyen típusosztályba(pl: diszkrét) tartozzon;-- megadhatóak a használni kívánt további műveletek- kikerülhető közös ős megléte;-- explicit megadott műveletekkel még rugalmasabb használat(pl: rendezési relációt egész számokon példányosítva lehet oszthatóság parciális rendezési relációját megadni); -- pl: generic type Item is private; type Index is (<>); type Vector is array(Index range <>) of Item; with function „<”(X,Y: Item) return Boolean is <>; procedure Log_Search(V: in Vector; X: in Item; Found: out Boolean; Ind: out Index) is M,N,K: Integer; begin M:=Index’Pos(V’First); N:=Index’Pos(V’Last); Found:= False; while not Found and then M<=N loop K:=(M+N)/2; if X<V(Index’Val(K)) then N:= K-1;

- 34 -


elsif X=V(Index’Val(K)) then Inf:=Index’Val(K)); Found:=True; else M:=K+1; end if; end loop; end Log_Search; -- példányosítás: …ezt már nem!!!

- Java 5.0: generic bevezetése;-- eddig: List myIntList= new LinkedList(); myIntList.add(new Integer(0)); Integer x= (Integer) myIntList.iterator().next();-- most már: List<Integer> myIntList= new LinkedList<Integer>(); myIntList.add(new Integer(0)); Integer x= myIntList.iterator().next(); ehhez java.util-ban: public interface List<E> extends Collection<E> { void add(E x); Iterator<E> iterator(); …} ; public class LinkedList<E> extends AbstractSequentialList<E> impelments List<E>, Queue<E>, Clonable, Serializable… ;

- 35 -


10. Helyességbizonyítást támogató nyelvi eszközök (példák: Alphard, Eiffel)

Programozás feladata: egy feladat megoldása; Programozás lépései: tervezés, kódolás, tesztelés;

Tervezés:- Feladat elemzése: információk gyűjtése: adattípusok meghatározása(állapottér), előfeltétel (bemenő adatok és rájuk érvényes állítások), utófeltétel (eredmény adatok és rájuk érvényes állítások), szerződés;- célja: egy feladatot egy megengedett programmal oldjunk meg: üres program; a:= F(a) értékadás; szekvencia; megengedett feltételeket használó elágazás; megengedett ciklusfeltételű ciklus programszerkezeteinek segítségével felépített program; - ha feladat triviális megoldása nem megengedett, akkor részfeladatokra bontani, amíg megengedett elemet nem kapunk;- egy (rész)feladatot triviálisan megoldó nem-megengedett értékadást: bonyolultabb szerkezetű programmal (proceduális) vagy értékadás jobboldali kifejezésének kiszámításánál használt, nem-megengedett típusműveletek valósítják meg (típus-orientált programtervezés);- pl: macska becsapódási sebessége: lényeges adatok, összefüggések(v= gyök(2gh)), állapttér(h: R, v: R), előfelt(=ef): h=h’, utófelt: ef és v= gyök(2gh);

Helyesség ellenőrzése:- első programok megjelenésével módszerek kidolgozása megkezdődött;- objorientált prognyelvek: központi fogalma absztrakció, absztrakt adattípus típust specifikációval, implementáció, reprezentációs fv(közöttük lévő kapcsolat); - helyességbizonyításhoz olyan módszerek kellenek, amelyekkel a típusspecifikációt és implementációt adhatjuk meg kettős specifikáció (ellenőrizni, hogy imp megfelel-e spec-nak);

Típus:- adat által felvehető lehetséges értékek halmaza (típusértékhalmaz) és az ezen értelmezett műveletek (típusműveletek) együttesen határozzák meg (specifikálják); - specifikáció módja: elő és utófeltételes, pl: Alphard, Eiffel, Euclid, Turing;

- Alprogramoknak megadhatunk-e és ha igen, milyen formában elő- és utófeltételeket?- A típushelyesség ellenőrzéséhez megadhatunk-e specifikációs és típusinvarinást?- Kezeli-e a specifikációs elő- utófeltételek és az implementált program elő- és utófeltételeinek különbségét, és így ellenőrzi-e a megfelelés helyességét?- Vannak-e eszközei a ciklushelyesség ellenőrzésére?- Exception-helyességet támogatja-e? (legalább típusinvarinást helyre kell állítani)- Milyen az öröklődés és az elő- és utófeltételek, valamint típusinvariáns kapcsolata?

- 36 -


Alphard: - 70-es évek 2.felében; cél: Hoare-féle helyességbizonyításhoz egy megfelelő specifikációs eszköz kidolgozása, de implementálásig nem jutott el (mégis oktatják, mert speciális leehtőségek és kifinomult);- típus: form; megadása: form típusnév (formális paraméterek)= beginform specifications … representation … implementation … endform; - spec: requires..formális paraméterekre vonatkozó megszorítások; let..típus leírására használt absztrakt adattípus (itt: integerek sorozata); invariant..típusinvariáns (példányosítás a konkrét térben fog megtörténni); reprezentációs fv..representation-ben, visszaképez erre absztrakt adattípusra- minden konkrét térben inicializált objektumra alkalmazzuk reprezentációs fv-t (ezeknek ki kell elégíteniük initiallyban megadott feltételt); initially..absztrakt kezdeti objektum tulajdonságait írja le; function..adt műveleteit specifikáljuk elő-utófeltételekkel; - pl: form istack (n:integer)= beginform specifications requires n>0; let istack=<…,xi,…> where xi is integer; invariant 0<= length(istack)<= n; initially istack= nullseq; fuction push(s: istack, x: integer) pre 0<= length(s)< n post s= s’~x, pop(s: istack) pre 0< legth(s)<= n post s= leader(s’), top(s: istack) returns x: integer pre 0< length(s)<= n post x= last(s’), isempty(s: istack) returns b:boolean post b=(s=nullseq); representation unique v: vector(integer,1,n) sp: integer init sp<-0; rep (v,sp)= seq(v,1,sp); invariant 0<= sp<= n; states empty when sp=0, normal when 0< sp< n, full when sp=n, error otherwise; implementation: body push out (s.sp=s.sp’+1 és s.v= a(s.v’, s.sp,x))= empty, normal:: (s.sp<- s.sp+1; s.v[s.sp]<-x); otherwise: FAIL; body pop out (s.sp= s.sp’-1)= normal, full:: s.sp<-s.sp-1; otherwise: FAIL; body top out(x= s.v[s.sp])= normal, full:: x<-s.v[s.sp]; otherwise: FAIL; body isempty out (b=(sp=0))= normal, full:: b<-false; empty:: b<-true; otherwise: FAIL; endform;

- 37 -


- form helyességének belátása : Ia..spec invariánsa, IC..repr invariánsa, ßreq..spec reqiures, ßinit..spec initially, finit..inicializáció művelete, f..többi, {}..műv végrehajtása; prea

f és posta

f..f absztrakt műv-hez tartozó elő és utófelt; precf és postc

f..konkrét szinten; -- reprezentáció helyességének ellenőrzése: Ic(x)=> Ia(rep(x));-- obj inicializálásának ellenőrzése: ßreq {finit} (ßinit(rep(x)) és Ic(x)); -- minden f műveletre:a) konkrét művelet helyességének ellenőrzése: prec

s(x) és Ic(x) {S} postcs(x) és Ic(x);

b) konkrét és absztrakt specifikáció közötti kapcsolat ellenőrzése: Ic(x) és preaf(rep(x)=>

precs(x) ill Ic(x) és prea

f(rep(x’)) és postcs(x)=> Ic(x) és posta

f(rep(x));

- 38 -


Eiffel:- beépített nyelvi eszközökkel rendelkezik formális specifikációk megadására;- rendszer ellenőrizni tudja, hogy egyen programegységek nem sértik-e specifikációt; - típusok műveleteinek elő-utófeltételes specifikációja fontos módszertanában- felhasználják követelmények pontosabb megfogalmazására, teszteléskor, dokumentációs célokra; - nyelv tervezésekor nem volt cél, hogy biztosítsa a program helyességét, mert ez gyakorlatban nem oldható meg; - elő-utófelt: előremegy egy pozíciót: forth is require mot after: not after do … ensure position= old position+1 end ; put item v at i. position: put_i_th(v: like first; i: integer) is require index_large_enough: i>=1; index_small_euough: i<= count; deffered ensure not empty end ;- C osztály konzisztens: minden p kosntruktor eljárásra: prep {dop} INVc; minden r metódusára: prer és INVc {dor} postr és INCc; - kvantor: megadására nincs lehetőség, de használhatjuk old és strip operátorokat; -- old: obj végrehajtandó metódusába való belépés előtti állapota, pl: x= old x+1 ;-- strip: attribútumok, amelyek a metódus végrehajtása közben megváltozhatnak, pl: strip(a,b..).. obj összes mezője kivéve a,b; így pl: equal(strip(a,b),old strip(a,b)); - ciklushelyesség: C osztály r metódusa akkor és csak akkor, ha minden ciklusra:True{Init} Inv; True{Init} Var>=0; INV and then not EXIT{Body} INV; INV and then not EXIT and then (Var=v){Body} 0<= Var< v;pl: from go_before invariant 0<= child_position; child_position<= arity+1 variant arity- child_position+1 until child after or else(j=i) loop child_forth; if (sought=child) then j:=j+1 end end ;-- invariáns: minden lefutás előtt és után igaznak kell lennie;-- variáns: ha véges ciklust akarunk írni;- Exception helyesség: egy C osztály r rutinja akkor és csak akkor, ha a rescue blokkjának minden b ágára a következő igaz: ha b egy retry-jal kezdődik, akkor true{b} INVc and prer; ha b nem retry-al kezdődik: true{b} INVc; - öröklődés és helyesség: rutin újradefiniálása azt jelenti, hogy alszerződést kötök a leszáramzottal (amire klinesek már ősével kötöttek ~ alvállalkozó), azaz megtartja v gyengíti előfelt(nincs új követelménye kliens felé, ill megtartja v szűkíti utófelt(eredmény legalább olyan jó, mint eredeti szerződésben); -- elő és utófeltételek újradeklarálódhatnak- require else..alterntív előfeltétel, ensure then..extra utófeltétel; -- pre1..pren az ősök előfeltételei (or else); post1..postn az ősök utófeltételei (and then kapcsolat); -- metódus előfeltétele: alternatív előfeltétel or else pre1 or else… or else pren;-- utófeltétele: alternatív utófeltétel and then post1 and then… and then postn; - álíltások:-- check: program tetszőleges pontján elhelyezhetünk egy álíltást, amelyet a futtató rendszer ellenőriz;-- no: nem ellenőrzi az állításokat;-- require: mindig az előfeltételeket ellenőrzi;-- ensure: elő és utófelt ellenőrzése;-- invariant: előzőeken túl osztályinvariánst is;-- loop: előzőeken túl ciklusokat is;-- all: előzőeken túl ckeck utasítások ellenőrzése;

- 39 -


11. Objektumorientált programozás 1.Osztályok és objektumok, objektum létrehozása, inicializálása, példányváltozó, példánymetódus, osztályváltozó, osztálymetódus, társítási kapcsolatok(példák: Java, C++, Smalltalk)

OO paradigma: egy program OO, ha valós világot modellezi; jellemzői: - objektum, osztály; - társítási kapcsolatok; - öröklődés;

- valós világ modellezése: világ megértéséhez modelleket épít; modellezési alapelvek:- absztrakció: szemléletmód, amelynek segítségével valós világot leegyszerűsítjük (csak lényegre, cél elérése érdekében feltétlenül szükséges részekre összpontosítunk; és elvonatkoztatunk a számukra pillanatnyilag nem fontos közömbös információktól);- megkülönböztetés: objektum: modellezhető valós világ egy-egy önálló egységét jelöli; objektumokat számunkra lényeges tul, viselkedési módjuk alapján különböztetjük meg; - osztályozás: kategóriákba soroljuk- hasonló tul egy osztályba, kül/eltérű tul külön osztályba; objetkum-osztály: hordozza a hozzá tartozó obj-ok jellemzőit; pl: kutya;- általánosítás, specializálás: objektumok között állandóan hasonlóságokat v különbségeket keresünk- ezáltal bővebb v szűkebb osztályokba soroljuk őket; - kapcsolatok felépítése, részekre bontás: ismeretségi (használati), tartalmazási (rész-egész) kapcs;

OO program: egymással kommunikáló objektumok összessége, melyben minden objektumnak megvan a feladatköre; Objektum: adattagok+ műveletek (algoritmus, metódus); információt tárol, kérésre feladatot hajt végre; belső állapota van, üzeneten keresztül lehet megszólítani; felelős feladatainak korrekt elvégzéséért; pl: ablak obj: aFrame: (20,160) – location(x,y), (100,80) – size(width,height), „Ablak” – title, true – visible;

- obj állapota: mindig van (adattagok pillanatnyi értékei írják le); ugyanaz, ha adattagok értékei megegyeznek; operációk hatására állapota megváltozhat; mindig emlékszik állapotára;- obj azononssága: minden obj egyértelműen azonosítható; azonossága független tárolt értékekektől; akkor sem azonos, ha állapotaik megegyeznek!;

Osztály: class; olyan objetumminta vagy típus, mely alapján példányokat(objektumokat) hozhatunk létre; pl: Ember: pozíció(x,y); iránySzög; megy(táv); elmegy(x,y); fordul(szög);Példány: instance; minden obj születésétől kezdve egy osztályhoz tartozik; Kati, Andor;

- 40 -


Osztály neve; adatok/attribútumok/információk/változók/mezők; metódusok/peroációk/rutinok; UML= Unified Modelling Language;

- obj létrehozása, inicializálása: életciklusa: megszületik, él, meghal; konstruktor végzi; adatok kezdőértékadásai; obj működéséhez szükséges tevékenységek végrehajtása; típusinvariáns beállítása; -obj műveletei: -- export: amelyeket más objektumok hívhatnak (pl: verem: push, pop, top); --- létrehozó(= konstruktor): obj létrehozására, felépítésére, pl: create: verem;--- állapot megváltoztató: pl: pop: verem verem; push: verem x elemverem;--- szelektor: kiemeli obj bizonyos részét, pl: vektor adott indexű eleme: access: vektor x index elem;-- kiértékelő: obj jellemzőit lekérdező műveletek, pl: size, has;--- iterátor: bejáráshoz; -- import: amelyeket az obj igényel ahhoz, hogy export szolgáltatásait nyújtani tudja (pl: fix méretű verem vektoros reprezentáció: put, access vektorműveletek);

Kliens: aktív obj; másik obj-on végez műveletet; nincs export felülete;Szerver: passzív obj; csak export felülete van, nincs import felülete; másoktól érkező üzenetekre vár, mások szolgáltatását nem igényli;Ágens: általános obj, van export és import

felülete;

- 41 -


Példányváltozó: példányonként helyet foglaló változó;Példánymetódus: példányokon dolgozó metódus; csak 1x tárolom; végrahajtom, ha van rá hivatkozás; hivatkozhat: osztály, pédlány változóira;Osztályváltozó: osztályonként helyet foglaló változó; jelölés: aláhúzva; Osztálymetódus: osztályokon dolgozó metódus; úgy is lehet hívni, hogy nincs példánya; hivatkozhat: csak osztály változóira;

This v self: - ha egy osztályból több objektumot példányosítunk, honann tudjuk, épp melyik obj hívta meg a megfelelő metódust és a metódus melyik obj adataival fog dolgozni;- self=this=current: mutató, amely mindi a metódust meghívó objpéldányra mutat (rámutat adeatorka, amelyekkel metódusnak dolgoznia kell); - ha obj saját magának akar üzenetet küldeni, akkor formája: self.üzenet(paraméterek);

Bezárás (=encapsulation; egységbe zárás; adatok ésmetódusok összezárása); információ elrejtése(=info hiding; obj belügyeit csak interfészen keresztül lehet megközelíteni); kód újrafelhasználás(=code reuse; példány létrehozásával vagy osztály továbbfeljesztésével);

Társítási kapcsolatok:- objektumok közötti: ismertségi (használati, pl: Ági: nő- házastársa –András: Férfi; Erzsébet: Ember- gyereke ->Zsófi: Ember); tartalmazási(rész-egész): gyenge(rész kivehető egészből, pl: doboz: Doboz o-

- 42 -


csoki: Édesség) v erős(nem vehető ki, pl: : Kutya o- :Láb(multiplicitás), @- :Törzs); egész obj mindig ismeri a részét; kompozíció: direkt szorzat;

- osztályok közötti: megszorítás(pl: rendezett), kapcsolat neve, kapocsoalt foka(multiplicitás), szerepnév;; ismertségi v tartalmazási; multiplicitás: egy-egy(Ember 1 -> 1 Útlevél), egy-sok(pl: Doboz 0..1 o- Ban van(nyíl) –0..1 Édesség; Ország o- Országa,Városa(nyilak) – 1.. Város; Ember 1-> *(rekurzívan) Gyereke,Anyja(nyilak)), sok-sok(Tanfolyam 1..* –Képzi, Jár(nyilak) – 2..10 Hallgató; Hallgató *-> *(rekurzívan)); kötelező v opcionális; -- megvalósítás: referencia másik osztály objektumaira; 1-sok: egyes oldalon listát tárolni (láncolt, halmaz, tömb), sok-sok: 2 konténer egy mutatóval kulcsokkal (láncolt lista);

- 43 -


12. Objektumorientált programozás 2. Öröklődés, polimorfizmus, dinamikus kötés, megbízható átdefiniálás leszármazottakban (példák: Java, C++, Eiffel)

Öröklődés:- alapgondolat: gyerekek öröklik őseik metódusait és változóit;- örököl: ősosztály minden metódusa és adattagja a gyerekosztálynak is metódusa és adattaja lesz;- gyerek minden új művelete vagy adata hozzáadódik eddigiekhez;- minden metódus, amit átdefiniáltunk gyerekben- felülbírálja az örökölt metódust; - ISA: leíró bővítésével (tul) szűkítem a halmazt; - pl: Rovarok: tulajdonságok; üzenetek –ős, Bogakrak: új tul; felüldef üzenetek, új üzenetek –utód; Dialog: location(x,y), size(w,h) –ős, FileDialog: file: String; getFile(): String, setFile(file: String) –utód; Ember: pozíció, IQ; megy(), tanul(), beszél(); --- Hallgató: osztályzat; tanul(); --- Tanár: tananyag; tanít(), beszél();; Ős: a, b; m1, m2; Utód: c, d; m1, m3; o1: Ős: a,b (küldhető üzenet: m1,m2; végrehajt: Ős.m1, Ős.m2); o2: Utód: a,b,c,d (küldhető: m1,m2,m3; végrehajt: Utód.m1, Ős.m2, Utód.m3);

- 44 -


Polimorfizmus: /=din összekapcs;- többalakúság; egy változó nem csak egyfajta típusú obj-ra hivatkozhat; pl: a:=b; (csak akkor jó, ha referencián keresztül megy, értékül nem adhatom); -- statikus típus: deklaráció során kapja;-- din típus: run-time éppen milyen típusú obj-ra hivatkozik (stat típus v annak leszármazottja);

- altípusos polimorfizmus: altípus használható szupertípus helyén;Ha B (pl: Triange, Quadrangle) altípusa az A(pl: Shape) típusnak, akkor B objektumainak referenciái értékül adhatóak A típus referenicáinak; pl: Shape s; s= new Trinagle(…); s= new Quadrangle(…);

Dinamikus összekapcsolás: - runtime fogalom; az a jelenség, hogy a változó éppen aktuális dinamikus típusának megfelelő metódus implementáció hajtódik végre; pl: Shape a; Triangle h= new Triangle()…; Quadrangle t= new Quadrangle(..); a=h; a.draw(); a=t; a.draw(); - fordítási időben nem eldönthető;- Java: alapértelmezés; C++: virtual kulcszó (lassítja programot);

Öröklődés= altípus kézés;Altípus: szabályok: reflexív(T c T), tranzitív (T1 c T2; T2 c T3 T1 c T3); - fv alakja: AB, ha A típusú paramétere van és B típusú eredményt ad; - ha (A’B’) <: (AB), akkor első fvtípus minden elemét használhatjuk minden olyan kontextusban, ahol a másodikat; tfh: ha f: AB típusú fv, akkor f’: A’B’ fv-t f helyén használva A-beli argumentumot elfogadja és B-beli eredményt ad; mivel f’ ÉT-a A’, így akkor is alkalmazahtó A-beli elemekre, ha A<:A’ (ha a:A, az A’-belinek tekinthető és f(a) típushelyes), másrészt ha f’ eredménye B’, akkor B’<:B garantálja, hogy eredmény B-beliként kezelhető;- összegezve: (A’B’) <: (AB), ha A<:A’ és B’<:B; - pl: fss= proc (Shape) returns (Shape); fts= proc (Triangle) returns (Shape); fst= proc (Shape) returns (Triangle); ftt= proc (Triangle) returns (Triangle); fts c fss – nem jó(mivel TS<: SS szűkebb); ftt c fss – nem jó; fst c fss – monoton=kovariáns(eredmény lehet speciálisabb), fss c fst – anti-monoton=kontravariáns(paraméterek lehetnek kevésbé speciálisak);

OOP: - programozó definiálhat altípus kapcsolatokat; - altípusos polimorfizmus;- típus-vezérelt metódus elérés;- öröklődés;

- 45 -


- típus-vezérelt metódus elérés: s: Shape:= new Triangle(3,4,5); s.draw(); statikus (Shape draw metódusát hívja), dinamikus (Triangle draw metódusát hívja);-- elérési döntések: C++: őstípus virtual-nak deklarálja a metódust, amire megengedi a felüldefiniálást; Java: minden felüldefiniálható (hacsak nincs final); Eiffel: altípus redefine záradékot használ;- metódusok összekapcsolása: pl: s: Shape:= new Trinagle(3,4,5); h: int:= s.getHypotenuse(); s:= new Quadrangle(2,4,6,8); h: int:= s.getHypotenuse(); -- statikus ellenőrzés: mindkettő fordítási hiba (C++,Java, Eiffel);-- din ellenőrzés: első ok, második futási hiba (Smalltalk, Dylan); - alosztályképzés: gyakran használjuk az őstípus implementációját az altípus implementálására; oop nyelvek keverik altípus és alosztály fogalmakat; Eiffel (meg tudja mondani, mi mutat kifelé, pl: export {NONE} all), Java (interfészeket csak altípusra lehet használni), C++ (implementációs örölkés altípus nélkül: private, protected)

- 46 -


13. Objektumorientált programozás 3. A többszörös öröklődés problémái, lehetséges megoldásai, az interfészek fogalma, használata (példák: Java, C++, Eiffel)

Többszörös öröklődés: Shape- Quadrangle, Triangle, Equilateral; -- EquilateralTriangle; Paralellogram – Rectangle(Paralel), Rhombus(Equilat,Paralel), --- Square(Rect,Rhomb) ;- pl: bool Shape::is_equilateral() { return false;} bool Equilateral::is_equilateral() { return false; } Rhombus az most mi lesz??

Megoldások:- Java, Ada95, SmallTalk, BETA: nem engedi többszörös öröklődést (pl: Java: interfészek a többszörös őstípusra, de nem implementáció megosztása); prO. Biztonségos, egyszerű; con: korlátozza újrahasznosítást;- Eiffel: explicit átnevezés v elrejtés;- C++: explicit scope (::) operátor szükséges;

- altípus reláció S c T biztonságos:- altípus metódusai megőrzik az őstípus viselkedését:-- szignatúra: argumentumok kontravarianciája, eredmény kovarianciája; mS kivételei benne vannak mT kivételei között;-- metódusok szabálya: előfelt: kontravariancia (altípus gyengébb), utófelt: kovariancia (altípus erősebb); altípusok megőrzik a szupertípusok tulajdonságait- típusinvariánsukra (kovariancia); pl: Sportoló <- Síelő: szbatárs(Síelő)- Síelő_Fiú, Syelő_Lány; Sielő lány szobatárs felüldefiniálása: konvariancia: szobatárs(Sielő_Lány); kontravariancia: szobatárs(Sportoló); novariancia: szobatárs(Síelő); probléma: s: Síelő, g: Síelő_Lány, b: Síelő_Fiú; s:=g; s.szobatárs(b) – csak futási időben derül ki, hogy nem jó;- C++: be lehet vezetni kovariáns metódusokat altípusban, de ezek túlterhelik az eredeti metódust, nem átdefiniálják; pl: class sielo{ public: virtual void szobatarts(sielo *s) {cout<<”sielo szobatarsa sielo”; }; }; class sielo_lany: public sielp { public: virtual void szobatars(sielo_lany *g) { cout<<”sielo_lany szobatartsa lany”; }; - túlterheli; virtual void szobatars(sielo *g) { cout<<”szobatars sielo_lanyban”; }; - átdefiniálja }; void main() { sielo *s; sielo_lany *g; sielo_fiu *b; g= new sielo_lany; s=g; s->szobatars(b); – nincs hiba, sielo::szobatars-at hívja; g->szobatars(g) – túlterhel (sielo_lany::szoabtars); s->szobatas(g) (sielo::szobatars); - Eiffel: lehet bevezetni kovarinás metódusokat az altípusban; nem típusbiztos; pl: class Sielo feature szobatars(Sielo s)… end class Sielo_lany inherit Sielo redefine szobatars end feature szobatars(Sielo_lany g) … end ;

- 47 -


Többszörös öröklődés problémái: Pl: class A{ public: int a; void* f(); }; class B: public A { public void* f(); }; class C: public A{ public voi* f(); }; class D: public B, public A{…}; - ha egy D-beli „f”-re (felüldefiniáltuk B-ben és vagy C-ben) hivatkozunk, akkor melyik jelentése? A vagy B vagy C?- „a” attribútum hány példányban jelenjen meg D-ben?- azaz ha kétértelműség, hogyan válasszunk?

Megoldási variációk:- ált nem lehet kódot lefordítani- fordító v futtató környezet kétértelműségre (ambiguous) hivatkozva hibajelzéssel leáll;-- származtatott osztály mondja meg melyiket szeretné használni;-- ősosztály mondja meg, mit szeretne tenni ilyen esetben; - C++: D d; d.f(); int i= d.a; - ambiguous; megoldás: class D: public B, public C { public: using B::a; using C::F; }; - Eiffel: rename; pl: class D inherit C rename a as ac end B feature … end ; class A.. feature f … end; class B inherit A redefine f… end; feature f… end; class C inherit A redefine f… end; feature f… end; class D inherit B rename f as bf… end; C rename f a cf select cf … end; feature … end;

Absztrakt osztályok: Java: interfész;- tervezés eszköze;- egy felső szinten összefogja közös tul-okat;- metódusok között van olyan, aminek csak specifikációja van, törzse nincs;- nem hozható létre példánya;- a leszármazott teszi konkréttá;Pl: Repülő<<interfész>>: felszáll(), leszáll(), repül(); Utasszállító<<interfész>>: létszám(), beszáll(utas), kiszáll(utas); Madár: felszáll(), leszáll(), repül(), eszik(), fészketrak(); Repülőgép: felszáll(), leszáll(), repül(), létszám(), beszáll(utas), kiszáll(utas); Autóbusz: várakozik(), megy(), létszám(), beszáll(utas), kiszáll(utas); - láthatóság: objektum védelme: publikus, védett, privát adat ill metódus;

- 48 -


OOP fő elvei:- moduláris struktúra;- absztrakció;- osztályok;- öröklődés;- polimorfizmus, dinamikus összekapcsolás;- többszörös örökléődés;- automatikus memóriakezelés;

- Van-e öröklődés?- Van-e többszörös öröklődés?- Adattagok és metódusok elrejtése hogy van megoldva?- Támogatja-e a polimorfizmust és din összekapcsolást? (esetleg csak mutatókkal)- Van-e alapértelmezett ősosztály? (pl: Object); - Van-e absztrakt osztály?- kosntruktor-destruktor?- GC?- standard obj könyvtárak?- osztályszintű attribútumok és metódusok?

Legkevésbé OOP: Assembler- C- C++- Java- Smalltalk – legjobban;

- Simula67: osztály(class), öröklődés, osztályhierarchia először; blokk és osztály fogalma összeolvad; önálló típusfogalom- először; van: din összekapcs, láthatósági védelem(hidden, protected), standard könyvtárak, GC, this pointer, virtual; nincs: többszörös öröklődés;- SmallTalk: -- minden obj (Integer, Character, még üzenetek is, amit obj-nak küldünk); változók típusnélküliek (nem tudjuk milyen tíőusú obj-ra mutat- RTTI(=runtime type information)); szabványos objkönyvárak(Array, String, FileStream); VM, GC; szintaxis könnyen tanulható: object message, pl: my Window drawCycle; myAge +1; -- minden obj egy osztály példánya (osztály egy metaosztály példánya);-- class üzenet: obj osztályát adja vissza;-- subclass üzenet: osztály definiálása szülőnek küldött üzenettel;-- nincs többszörös örökéls (nincs anomália);-- láthatóság: nincsenek predikátumok, de a belső változók minden alosztály számára láthatóak, de kívülre nem; metódousok gobálisak;-- van osztályszintű attr, metódus; -- közös ősosztály: Object(obj. );-- konstruktor(osztálynak küldött üzenet), destruktor: nincs;-- nincs absztrakt osztály (azaz metódusokat definiálni kell, nem csak deklarálni); -- ablakozó környezet, egér; -- pl: Object subclass #Szamla isntanceVariableNames: ’egyenleg’ classVariableNames: „ … init egyenleg:=0 ;

- 49 -


- C++: -- C nyelv egyik OOP kiterjesztése;-- Simula-féle objelvűséget követi; -- nincs GC(=Garbage Collector); -- adattagok és metódusok elrejtése megoldott (láthatóság: public, protected, private);-- van többszörös öröklődése;-- van polimorfizmus és din összekapcs, de csak mutatók esetén; -- virtual: fv-ek din összekapcsolásához;-- öröklődés minősítője: public(midnen ugyanoda), protected(public+prot prot), private(pub+prot+priv priv); -- nincs defalut ősosztály;-- lehet absztrakt osztály; -- konstruktor (ha kell implicit hívódik, mert nincs obj konstruktor nélkül): neve ua, ah megadunk egyet, akkor defalut nem definiálódik, nincs visszatérési értéke; -- destruktor: explicit hívni (delete) v implicit blokkból való kilépéskor; hívási sorrendje kosntruktorok ellentettje; -- ált metódus deklarációja: elérheti privát mezőket, osztály scop-ját használja, egy konkrét obj-ra hívódik meg (birtokolja this pointert), ha statikus, akkor csak első2 pont érvényes rá;-- friend mechanizmus: ha fv-t így delkarálunk, akkor 1. jogunk lesz (eléri private mezőket); -- van din összekapcs, töbszörös öröklődés (megondás: using);

- Object Pascal:-- következetlenségek: (2 kulcsszó 1 helyett) object- class, virtual- dynamic; láthatósági megkötések, de fájlon belül nem érvényes;-- jó ötlet: property (egyenlet bo-n áll), pl: property r: word read olvas write ír default 5;-- automatikus memóriakezelés;-- közös ős(TObject);-- absztrakt metódusok;

- Java:-- rokon SmallTalkkal;-- van GC;-- objelvű: gyakorlatilag minden obj;-- nincs osztályon kívüli(globális) változó;-- nincs többszörös örölkődés (helyette interface); extends helyett implements;-- szabványos osztálykönyvtárak( pl: java.awt);-- beépített típusoknak csomagoló (wrapper) osztálya, amely felelős konverióért, kiíratásért; -- final: osztálynév előtt(tiltja további származtatást), metódus előtt(tiltaj felüldefiniálást), változó előtt(tiltja kezdeto érték megváltoztatását); -- abstract: osztály előtt(eleve, implicit absztrakt), metódus előtt(deklarálható, de nem definiálható adott osztályban); egy osztály nem lehet egyszerre final és abstract; -- nincs operátortúlterhelés (de amúgy van);-- metódus módosítói: native, private, protected, static, synchronized;

- 50 -


-- ha osztálynak nincs kosntruktora, akkor generál (super()); -- nincs destruktor (GC);-- interface: metódusok egy csoportját specifikálja, törzsük implementálása nélkül (anomália: egyszerűbb helyzet);

- Eiffel:-- többszörös öröklés;-- metódus: defalut virtuálisak; nincs private;-- van absztrakt osztáy és metódus;-- leszármazott mondaj meg, hogyan szeretné örökölt attribútumokat és metódusoakt felhasználni (nincs anomália);-- metódus felüldefiniálható; -- művelet absztraktáá tehető (deferred);-- átnevezés (rename); -- van osztályhierarchia (general- paltform- any- …);-- láthatóság: none, any;

- 51 -


14. Párhuzamosság Alapfogalmak, kommunikációs modellek, szemafor, monitor, fontos nyelvi elemek (példák: Java, Ada)

- 52 -

Database Systems_______ 2000, Springusers.itk.ppke.hu/~eszdo/itk/prognyelv_vizsga.doc · Web...

Documents

Transcript of Database Systems_______ 2000, Springusers.itk.ppke.hu/~eszdo/itk/prognyelv_vizsga.doc · Web...