Tételsor a Programozási nyelvek (Ada) tárgyhoz 1-10

Átírás

1 Tételsor a Programozási nyelvek (Ada) tárgyhoz Légy szíves ha hibát találtok benne, vagy hozzá tudnátok rakni valamit akkor írjatok nekem! lexybunnyy@gmail.com Első feltöltve: felhasznált anyagok: Egy program 4 memóriaterületet kap az operációs rendszertől, ezek a CODE, a GLOBAL, a STACK és a HEAP angol elnevezéseken futnak. STACK: magyarul verem, (végrehajtási verem). Működése: ha egy függvényhívás/metódushívás történik, akkor a verembe bekerül legfelülre egy úgynevezett aktivációs rekord. Ez az aktivációs rekord tárolja az adott függvény/metódus kapott paramétereit és az automatikus helyfoglalású változóit. (pl: nem pointeres változók) (még más dolgokat is tárol itt, mint pl., hogy hova kell visszaugrania majd a vezérlésnek) Ha a függvény/metódus véget ért, akkor a veremből a legfelső aktivációs rekord automatikusan törlődik, annak összes változójával együtt. Minden újabb blokknyitás új aktivációs rekordot nyit.

2 Tartalom: - 1

3 Tételsor a Programozási nyelvek (Ada) tárgyhoz ) Kifejezések szintaktikus építőkockái. Tiszta és mellékhatásos kifejezések. Operátorok arítása, fixitása, precedenciája és asszociativitása, példák. Kifejezések kiértékelése. Lusta kiértékelés. 2 Kifejezések szintaktikus építőkockái Operandusok, operátorok, konstansok, változók: Tiszta és mellékhatásos kifejezések. mellékhatás: egy kifejezés vagy függvényhívás állapotváltozást idéz elő a programban általában nehezíti a program megértését, kerülendő o pl C++: globális változó megváltoztatása függvényhívásnál, úgy hogy nincs a paraméterek között; tisztán funkcionális nyelvek: nincsen mellékhatás (hivatkozási átlátszóság) példák: function Számláló ( R: Racionális ) return Integer is return R.Számláló; end; --nem változtat az értéken, csak visszatér vele. with Ada.Text_IO; with Ada.Integer_Text_IO; use Ada.Text_IO; use Ada.Integer_Text_IO; procedure Negyzet is N: Integer := 1; Put(N); //Nem változtat az N értékén end Negyzet; procedure Push( V: in out Verem; E: in Elem ); Egy in típusú formális paraméternek nem adhatunk értéket, csak olvashatjuk. Egy out módú paramétert lehet írni, és ha már kapott valamilyen értéket az alprogramon belül, lehet olvasni is. Egy in out módú paraméter értékét olvashatjuk és írhatjuk is. pl C++: ++i; i++ (mellékhatásos) Az eljárások általában a változók által kifeszített téren (állapottéren) vagy a program környezetén elvégzendő transzformációkat adnak meg. A függvények valamilyen értéket állítanak elő, de transzformációt nem végeznek. Sem a program változóinak értékére, sem a program környezetére nincsenek semmilyen hatással: a függvényeknek nincs mellékhatásuk. (Elméletben!) Operátorok arítása, fixitása, precedenciája és asszociativitása, példák. Arítás: e szám a reláció aritása, változói száma (a reláció nulláris, unáris, bináris, ternáris stb. azaz null-, egy-, két-, három- stb. -változós, ha rendre n=0, n=1, n=2, n=3, ); Fixitás: az operandusokhoz képest hol helyezkedik el az operátor szimbóluma? Precedencia: zárójelezési ("kötési") szabályok Asszociativitás: azonos precedenciájú operátorok kötésének meghatározására Pl: Táblázatokból lehet szemezgetni (elsősorban ez is C++ :S )

4 Precedencia Operátor Rövid leírás Asszociativitás Jelölés Csak C++-ban Túlterhelhető 1 :: Hatókör-feloldás nincs a::b, ::b Igen Nem () Csoportosítás (a) Nem [] Tömb-elérés a[] Igen Mutatón keresztüli tagelérés -> ptr->b() Igen 2 Bal Nem Objektumon keresztüli tagelérés. a.b() Nem ++ Posztfix növelés a++ Igen -- Posztfix csökkentés a-- Igen! Logikai tagadás!a Igen ~ Bitenkénti negálás ~a Igen ++ Prefix növelés ++a Igen -- Prefix csökkentés --a Igen - Előjel - -a Igen 3 Jobb Nem + Előjel + +a Igen * Dereferálás *ptr Igen & Objektum címe &a Igen (típus) Konverzió típusra (b)a Igen sizeof Méret sizeof(a) Nem ->* Tagkiválasztás a->*b() Igen 4 Bal Igen.* mutatón/objektumon a.*b() Nem * Szorzás 5 / Osztás Bal Infix Nem Igen % Maradékszámítás + Összeadás 6 Bal Infix Nem Igen - Kivonás << Bitenkénti eltolás balra 7 Bal Infix Nem Igen >> Bitenkénti eltolás jobbra < Kisebb <= Kisebb-egyenlő 8 Bal Infix Nem Igen > Nagyobb >= Nagyobb-egyenlő 9 Bal Infix Nem Igen 10 & Bitenkénti ÉS Bal Infix Nem Igen 11 ^ Bitenkénti kizáró VAGY Bal Infix Nem Igen Bitenkénti megengedő 12 Bal Infix Nem Igen VAGY 13 && Logikai ÉS Bal Infix Nem Igen Logikai(megengedő) 14 Bal Infix Nem Igen VAGY logikai-kif? 15? : if-then-else operátor Jobb kifejezés : Nem Nem kifejezés = Értékadás += Összeadás és értékadás -= Kivonás és értékadás *= Szorzás és értékadás /= Osztás és értékadás %= Maradékképzés és értékadás 16 &= Bitenkénti ÉS és értékadás Jobb Infix Nem Igen Bitenkénti kizáró VAGY és ^= == Egyenlő!= Nemegyenlő = értékadás Bitenkénti megengedő VAGY és értékadás <<= Eltolás balra és értékadás >>= Eltolás jobbra és értékadás 17, Szekvencia operátor Bal a, b Nem Igen 3 Aritás példa: a fenti táblázatban ami infix, annak értelemszerűen az aritása >=2, előjel+--nak 1(prefix); postfix és prefix is pl a ++ művelet a C++-ban

5 4 Kifejezések kiértékelése szekvencia pont: a programkód azon pontjai, amelyekhez érkezve garantált, hogy a megelőző kifejezések kiértékelése befejeződött szekvencia pontok között implementációfüggő a kiértékelési sorrend Összetett kifejezések kiértékelése ha egy részkifejezés kiértékelődött, az eredményét tárolni kell - létrejön egy átmeneti változó - a változó megkapja a részkifejezés eredményét (ez egy konstruktorhívás) - a kiértékelés folytatódik a kifejezés végén a menet közben lefoglalt átmeneti változók felszabadulnak Lusta kiértékelés C++: Rövidzáras (lusta kiértékelésű) logikai operátorok:, && - ha az első operandusból kiderül az érték, akkor a második operandust nem számítják ki true x == true false && x == false - ez különösen fontos akkor, ha a második kifejezés érvénytelen lenne x!= 0 && 100 / x < 4 // nullával való osztás elkerülése p && *p == 1 // nullmutató nem oldható fel Ada: Logikai típus (Boolean) - A Standard csomagban (automatikusan használható a programokban) - Az if és a while ezt igényli - Ilyet adnak: = /= < > <= >= - predefinit operátorok: not and or xor and then or else if B = True then if B then if B = False then if not B then Rövidzár logikai operátorok, Lusta kiértékelés: and then, or else - ha az első argumentumból meghatározható a kifejezés értéke, akkor megáll if A>B and then F(A,B) then Mohó kiértékelés: and or - mindenféleképpen kiértékeli mindkét argumentumot más eredmény: ha a második argumentum - nem mindig értelmes / kiszámítható (futási hiba) - mellékhatással rendelkezik Például Futási hiba - lineáris keresés tömbben while I <= N and then T(I) > 0 loop Mellékhatás - álvéletlenszám kérése if EOF or else Random(G) > 0.5 then

6 2) Értékadás. Értékadás összetett típusokra. Korlátozott típusok. 5 - Az értékadás : Egy kifejezés értékét egy változóhoz rendeljük I := 5; - Az érték és a változó típusának meg kell egyeznie I := True; -- fordítási hiba! - Futási időben további ellenőrzés (altípus) - A korlátozott típusú változóktól eltekintve minden változóra alkalmazható (sőt, balértékre ) - Az értékadás nem kifejezés, a := pedig nem operátor (nem definiálható felül, viszont van Controlled) - Nincs szimultán értékadás Szimultán értékadás: Az értékadás egyszerre több változó értékét is megváltoztathatja, ezért ún. szimultán értékadásról van szó. Összetett típusok: tömb - rekord - jelölt - taszk t. -védett t. type Napok is (Hétfô, Kedd, Szerda, Csütörtök, Péntek, Szombat, Vasárnap); subtype Munkaórák is Natural range 0..24; Munka: array (Napok range Hétfô.. Péntek) of Munkaórák; Munka(Szombat):=6; Munka(Hétfô):= 22; Többdimenziós tömb type T is array (Boolean, Boolean) of Boolean; És: T := ( (False, False), (False,True) ); És(False,True) Tömbök tömbje type T1 is array (Boolean) of Boolean; type T2 is array (Boolean) of T1; Vagy: T2 := ( (False,True), (True,True) ); Vagy(False)(True) --Sorfolytonos ábrázolás type T is array ( ) of Integer; X: T := (0,2,4,6,8,1,3,5,7,9); X ' First --az első index, azaz 1 X ' Last --az utolsó index, azaz 10 X ' Range --X ' First.. X ' Last X ' Length --az X hossza, azaz 10 type T is array (Boolean, Boolean) of Boolean; És: T := ( (False, False), (False,True) ); --És ' First(1) az első index az első dimenzióban, azaz False --És ' Last(2) az utolsó index a második dimenzióban, azaz True Altípus létrehozása type Beosztás is array (Napok range <>) of Boolean; subtype Munkanap is Beosztás(Hétfô.. Péntek); Kati_Beosztása : Beosztás(Kedd.. Szombat); Jancsi_Beosztása : Munkanap; Peti_Beosztása : Beosztás := (True,True,False); - Ilyenkor Napok'First az első index - Megtévesztő lehet, ha Integer az indextípus:

7 Értékadás szeletre: a szelet is balérték W(1..3) := (3,5,1); Nem teljesen meghatározott típus Nem lehet közvetlenül változót definiálni vele nem ismerjük a méretét de például helyes ez: X: T := (1,5,3); 6 A String típus S1: constant String := "GIN"; S2: constant String := ('G','I','N'); Különböző méretű String-ek nem adhatók egymásnak értékül: Constraint_Error S: String(1..256); S := Integer'Image( Faktoriális(4) ); Tömbaggregátum type T is array (1..6) of Float; --Pozícionális megadás X: T := (1.0, 3.0, 1.0, 2.0, 2.0, 2.0); --Névvel jelölt megadás X: T := (2 => 3.0, 1 3 => 1.0, 4..6 => 2.0); --Maradék X: T := (2 => 3.0, 1 3 =>1.0, others => 2.0); --Keverés X: T := (1.0, 3.0, 1.0, others => 2.0); Korlátozás nélküli index esetén type T is array (Integer range <>) of Float; --Pozícionális megadás X: T := (1.0, 3.0, 1.0, 2.0, 2.0, 2.0); --Névvel jelölt megadás X: T := (2 => 3.0, 1 3 => 1.0, 4..6 => 2.0); --Helytelenek: X: T := (2 => 3.0, 1 3 =>1.0, others => 2.0); X: T := (1.0, 3.0, 1.0, others => 2.0); --Helyesek: X: T(1..10) := (1.0, 3.0, 1.0, others => 2.0); X: T(1..10) := (2 => 3.0, 1 3 =>1.0, others => 2.0); Többdimenziós esetben M: Mátrix(1..2, 1..3):= (1 = > (1.1,1.2,1.3), 2 = > (2.1,2.2,2.3)); D: Mátrix := (1.. 5 = > (1.. 8 = > 0.0)); Record: type Honap is ( Januar,, December); type Datum is record Ev: Integer; Ho: Honap; Nap: Integer range ; end record ; --Hivatkozás a record elemeire: D: Datum; D.Ev := 2003; D.Ho := November; D.Nap := 22; Előre definialt műveletek D.Ev := D.Ev + 1; -- A mezőeleres --Az ertekadas es a (nem)egyenlőseg vizsgalat (ha nem korlatozott a tipus) if D1 /= D2 then D2 := D1; end if;

8 7 Az explicit konverzio (leszarmaztatott tipusnal) type Date is new Datum; Today: Date := Date(D); A tipus definiciojaban megadhatjuk a tipus objektumainak kezdőertekeit: type Komplex is record Valos, Kepzetes: Float := 0.0; end record; C: Komplex; I: Komplex := (0.0, 1.0) Korlátozott típusok - Az ertekadas es a (nem)egyenlőtlenseg vizsgalata letilthato: nincs := = /= - A tipus definiciojaban szerepel a limited type R is limited record end record; - Egy nezet is lehet korlatozott, peldaul a reszleges Korlatozott atlatszatlan tipus - Mikor egyenlő ket verem? - Mit jelent az ertekadas lancolt adatszerkezet eseten? - A C++ nyelvben feluldefinialjuk az ertekadas es egyenlősegvizsgalat operatorokat - Az Adaban az ertekadas nem operator - A limited kulcsszot hasznalhatjuk az atlatszatlan tipus reszleges nezetenek megadasakor - Az Ada95-ben van meg Controlled is Például: package Stacks is subtype Item is Integer; type Stack (Capacity: Positive) is limited private; procedure Push( V: in out Stack; X: in Item ); private type Item_Array is array( Integer range <> ) of Item; type Stack(Capacity: Positive ) is record Data: Item_Array(1..Capacity); Stack_Pointer: Natural := 0; end record; end Stacks; ekkor a Stack látható, de a record elemei(data, Stack_Pointer) nem.

9 3) Sekély és mély másolás, illetve összehasonlítás Futás közben egy új objektum létrehozásának alapvető eszköze a példányosítás. - Néha viszont szükség lehet arra, hogy egy már létező objektum tartalmát másoljuk át egy másik, már létező objektumba. - A másolás lehet sekély: amikor csak egyetlen objektumot másolunk - A másolás lehet mély,amikor a hivatkozott objektumokat is másoljuk Objektummásolás Ennek megfelelően az objektumoknak megkülönböztetjük két-féle másolási lehetőségét: sekély másolat (shallow copy): csak a referencia másolódik, az objektum maga ugyanazon a memóriaterületen lesz azaz ugyanaz történik, mint egy álnév létrehozásánál, vagy cím szerinti paraméterátadásnál, ha felülírunk valamilyen értéket a másolatban, az felülírja az eredeti értéket is mély másolat (deep copy): a teljes objektum másolódik egy ugyanakkora memóriaterületre értékmódosítások a másolatban nem lesznek hatással az eredeti objektumra érték szerinti paraméterátadásnál egyszerű változókra Amikor egy objektumot másolunk, akkor alapértelmezetten lemásolódik minden adattagja (mint a rekordoknál) azonban az objektumok szerkezete összetett lehet, tartalmazhat például mutatókat más objektumokra ha egy objektumban mutató található egy másik objektumra, akkor a másolás során a tartalmazott objektumnak csak sekély másolata készül el, ez nem mindig megfelelő Felül kellene definiálnunk a másolás folyamatát ahhoz, hogy ezt befolyásolni tudjuk, és a további, az objektumhoz tartozó adatokat le tudjuk másolni, a C++ erre biztosít lehetőséget,ha az objektumlétrehozást (konstruktor) szeretnénk túlterhelni. Összehasonlítás: Sekély esetén csak a referenciát hasonlítja össze ( ugyanazon a memóriacímen vannak-e? ) Mély összehasonlítás esetén megnézzük, hogy az értékeik ( a memóriacímeken tárolt adatok) megegyeznek-e. Ha a sekély másolat megegyezik, akkor a mély másolat is meg fog egyezni, de fordítva nem mindig teljesül. Lehetnek másik címen, és az értékeik ugyan megegyeznek, de a tárolt adatok nem.

10 4) Memóriaszivárgás. Az Ada Controlled típusai. 9 memóriaszivárgás: felszabadítatlan lefoglalt memória dinamikus tárterület (heap) Változók leképzése a memóriára Statikus A fordító a tárgykódban lefoglal neki helyet Automatikus Futás közben a végrehajtási vermen jön létre és szűnik meg Dinamikus változók dinamikus tárterületen jönnek létre Ahonnan a programozó allokátorral tud memóriát foglalni Explicit felszabadítás vagy szemétgyűjtés Utasítás hatására jön létre (és esetleg szabadul fel) a változó Statikus és automatikus: deklaráció hatására Mutató típusok A dinamikus változók használatához Ada: access típusok type P is access Integer; X: P; --Dinamikus változó létrehozása X := new Integer; --Dinamikus változó elérése a mutatón keresztül X.all := 3; Mutató típusok definiálása type P is access Integer; type Q is access Character; type R is access Integer; Meg kell adni, hogy mire mutató mutatók vannak a típusban: gyűjtőtípus P, Q és R különböző típusok Mutatók a C++ nyelvben Nincsen önálló mutató típus fogalom Mutató típusú változók int *x; Nem lehet két különböző int-re mutató mutató típust definiálni A Javában csak implicit módon jelennek meg a mutatók Mutató, ami sehova sem mutat : Nullpointer Az Adában: a null érték Minden mutató típusnak típusértéke type P is access Integer; X: P := null; Y: P; -- implicit módon null-ra inicializálódik Memóriaszivárgás A dinamikus memóriakezelés baja Mikor szabadítsunk fel egy változót? Dinamikus változó élettartama Az alias-ok miatt bonyolult Ha felszabadítom: nem hivatkozik még rá valaki egy másik néven? Ha nem szabadítom fel: felszabadítja más? Ha felszabadítom int *x = new int; int *y = identitás(x); delete x; *y = 1; // illegális memóriahivatkozás int *identitás( int *p ) { return p; } Ha nem szabadítom fel int *x = new int; x = másolat(x); // memory leak int *másolat( int *p ) { int *q = new int; *q = *p; return q; // return new int(*p); }

11 Megoldások Legyen ügyes a programozó Legyen szemétgyűjtés Használjunk automatikus változókat Ott a hatókörhöz kapcsolódik az élettartam C++: automatikus objektum destruktora Szemétgyűjtés Garbage collection Ne a programozónak kelljen megszüntetnie a nem használt dinamikus változókat A futtató rendszer megteszi helyette Nő a nyelv biztonságossága A hatékonyság picit csökken (a memóriaigény és a futásiidő-igény is nő) Megéri (kiforrott szemétgyűjtési algoritmusok) LISP (1959), Ada, Java, modern nyelvek Felszabadítás az Adában Szemétgyűjtéssel (alapértelmezett) A típusrendszer az alapja Explicit felszabadítással Ada.Unchecked_Deallocation A hatékonyság növelése érdekében Van, amikor csak így lehet A dinamikus változó felszabadul, amikor a létrehozásához használt mutató típus megszűnik Ekkor már nem férek hozzá a változóhoz alias segítségével sem, csak ha nagyon trükközök >Tehát biztonságos a felszabadítás A programozó szabadít fel Ha a mutató típus a program végéig létezik, nincs szemétgyűjtés A programozó kézbe veheti a felszabadítást Nem csak ilyenkor veheti kézbe Ada.Unchecked_Deallocation sablon ez felel meg a C++ delete-jének 10 Ada.Unchecked_Deallocation with Ada.Unchecked_Deallocation; procedure A is type P is access Integer; procedure Free is new Ada.Unchecked_Deallocation(Integer,P); X: P := new Integer; Y: P := X; Free(X); Y.all := 1; -- definiálatlan viselkedés end A; Memóriaszivárgás: Sorok egy láncolt szerkezet. with Sorok; procedure A is package Int_Sorok is new Sorok(Integer); procedure B is S: Int_Sorok.Sor; Int_Sorok.Betesz(S,1); end B; B; B; B; B; B; B; B; B; B; B; B; B; B; B; end A;

12 Mi történik? A sor objektumok a stack-en jönnek létre A sor elemei a heap-en allokáltak Amikor a sor objektum megszűnik (automatikusan), az elemek nem szabadulnak fel 11 Megoldás o Felszámoló eljárást írni, és azt ilyenkor meghívni procedure Felszabadít is new Ada.Unchecked_Deallocation(Csúcs, Mutató); o Így megelőzhetjük a memóriaszivárgást, mert minden alkalommal lefut a destruktor, és felszabadítja a lefoglalt tárterületet. o C++: a sor destruktorában felszabadítani o Ada 95: Controlled típust használni A Limited_Controlled típus Jelölt (tagged) típus o Újabb komponensekkel bővíthető rekord típus o Az OOP támogatásához (pl. dinamikus kötés) A Sor típus ennek egy leszármazottja (new) Definiál konstruktort és destruktort, amelyeket a leszármazott felüldefiniálhat o A konstruktor és a destruktor automatikusan lefut létrehozáskor, illetve felszámoláskor type Limited_Controlled is abstract tagged limited private; procedure Initialize (Object : in out Limited_Controlled); procedure Finalize (Object : in out Limited_Controlled); A Controlled típus Olyan, mint a Limited_Controlled De nem korlátozott típus A konstruktor és a destruktor mellett definiál értékadáskor automatikusan lefutó műveletet o Ez a primitív művelet is felüldefiniálható o Olyasmi, mint a C++ értékadó operátor felüldefiniálása o Saját értékadási stratégia (shallow/deep copy) o Szokás az = operátort is felüldefiniálni vele együtt procedure Adjust (Object : in out Controlled);

13 5) Strukturált és nem strukturált vezérlési szerkezetek. Az if-then-else probléma (avagy csellengő else). 12 Strukturált programozás esetén a program alapvetően programblokkokból áll. A blokkok vezérlési szerkezetekkel építhetők össze, alapvetően rákövetkezéssel, elágazással, és ciklussal. Strukturált programozási nyelvnek tekinthető az a nyelv, ami támogatja ezt a felépítést, pl. C, Pascal, Ada. A strukturált program ellentéte (a közhiedelemmel ellentétben) nem az objektumorientált program, hanem a strukturálatlan program. Ez utóbbit bármely olyan programozási nyelvben elő lehet állítani, amelyikben van közvetlen vezérlésátadás (goto utasítás). Egy folyamatábra gépi implementációja általában strukturálatlan programot eredményez; természetesen van algoritmus a strukturálatlan program strukturálttá alakítására. Struktúrált vezérlési szerkezet Összetett utasítások programkonstrukciók kódolására Elágazás: if, case Ciklus: léptetős, tesztelős, feltétel nélküli Blokk utasítás Elágazás: if if A>B then Temp := A; A := B; B := Temp; end if; Elágazás: if + else if A>B then A := A - B; else B := B - A; end if; Elágazás: if + elsif (+ else) if Aktuális < Keresett then U := I + 1; elsif Aktuális > Keresett then V := I - 1; else Megtaláltuk := True; - akárhány ág lehet end if; -- elhagyható az else Csellengő else le van zárva Pascal stb. if (a>0) if (b>0) c = 1; else c = 0 Elágazás: case (1) jár területei is break-kel felhasználási utasítással Ch : Character; -diszkrét típusú értéken case Ch is when d => X := X+1; when w => Y := Y-1; when a => X := X-1; when z => Y := Y+1; when others => null; end case;

14 13 case (X mod 20) + 1 is when => Felbonthatatlan := True; when others => Felbonthatatlan := False; end case; Ciklus: léptetős A ciklusváltozó: csak a ciklusban létezik nem külön deklaráljuk nem változtatható az értéke a ciklusmagban a ciklusmag lokális konstansa csak egy intervallumot adhatunk meg neki csak egyesével léphet with Ada.Integer_Text_IO; procedure Tízig is for I in loop Ada.Integer_Text_IO.Put(I); end loop; end Tízig; végre rvallum: ciklusmag nem hajtódik for I in reverse loop Ada.Integer_Text_IO.Put( I ); end loop; Ciklus: tesztelős (csak elöl) with Ada.Integer_Text_IO; procedure Tízig is I: Positive := 1; while I <=10 loop Ada.Integer_Text_IO.Put( I ); I := I + 1; end loop; end Tízig; Ciklus: feltétel nélküli olyan fontos programok) kilépés is exit utasítás A blokk utasítás Tartalmazhat újabb deklarációkat <utasítások> declare <deklarációk> <utasítások> end; <utasítások> loop... end loop; A blokk utasítás: beágyazás declare declare end; end;

15 14 A blokk utasítás: Mikor van rá szükség? részben kiváltható mutatókkal részben kiváltható mutatókkal kivételkezelő kód helyezhető el a végén Strukturálatlan utasítások: az exit utasítás (1) kran feltétel nélküli ciklushoz használjuk ciklust is köthető a kiugrás rövid szakaszán dől el, deklarálás előtt ki kell számolni loop exit; end loop; loop loop Get(Ch); exit when Ch = q ; exit when <felt.> end loop; end loop; A: for I in loop for J in loop if Beta(I,J) then exit A; end if; exit A when <felt.> end loop; end loop A; a goto utasítás <<COMPARE>> if A(I) < Elem then if Balszomszéd(I) /= 0 then I := Balszomszéd(I); goto COMPARE; end if; -- utasítások

16 6) Programszerkezet. Programegységek felépítése. Programegységek fajtái, melyik mire való. Könyvtári egységek, hivatkozás egymásra. Egymásba ágyazás. Minősített nevek. 15 Programegység, definíciójának felépítése (program unit, definition of a ~) Programegységnek nevezzük a program egy olyan szintaktikus egységét, mely a program tagolásának, programrészek újrafelhasználhatóságának eszköze. Programegységek például az alprogramok, a csomagok (Ada), az osztályok (C++), a taszkok (Ada) és a sablonok (Ada, C++). A programegységek definíciója két részből áll: specifikációból, amely leírja, hogy a programegységet hogyan kell használni, és törzsből, mely a programegység megvalósítását tartalmazza. Programegység specifikációja (specification) A programegység azon része, amely leírja, hogy a programegységet hogyan kell használni. Például egy alprogram specifikációja tartalmazza az alprogram nevét, formális paraméterlistáját, ha függvény, akkor a visszatérési értékét, C++ tagfüggvény esetén a this konstansságát, a Java esetén a láthatósági és egyéb módosítószavakat és a kiváltható kivételek listáját. Programegység törzse (body) A programegység megvalósítását tartalmazza. A programegységet használó programrészekből nem látszik. Ilyen az Ada csomagok törzse, vagy a C++ tagfüggvények definíciójának kapcsos zárójelekkel határolt része. Programegység deklarációja (declaration of a program unit) Akkor használjuk, amikor deklarálni, jelezni akarjuk, hogy egy adott név egy programegységre hivatkozik, de nem akarjuk a programegységet definiálni. A deklaráció tipikusan a programegység specifikációjából áll, így a fordító ellenőrizni tudja, hogy a deklarált nevet a programozó megfelelőképpen használja-e. Kölcsönösen rekurzív alprogramok definiálásánál sok nyelvben ilyen úgynevezett előrevetett deklarációt (forward declaration) kell alkalmazni. Másik példa: egy Ada csomagspecifikációban deklaráljuk a csomag által exportált alprogramokat, illetve egy C++ osztáydefinícióban a tagfüggvényeket lehet csak deklarálni (ilyen esetben az alprogram teljes definíciója az osztálydefiníción kívül helyezkedik el). Fordító (compiler) Forráskódból tárgykódot állít elő. Fordítás közben lexikális, szintaktikus és statikus szemantikai elemzéssel igyekszik felderíteni a program fordítási hibáit. Fordítási egység (compilation unit) A programszöveg azon része, amelyet a fordítóprogram egy egységnek kezel. (Az a rész, amit a fordító egy végrehajtásával le lehet fordítani.) Az Adában fordítási egységet lehet készíteni alprogramdefinícióból, csomag specifikációból, csomagtörzsből, sablon specifikációból, sablon törzsből, valamint alegységből. Például: egy alprogram definíciója, előtte az alprogram által használt könyvtári egységek listája (egy vagy több with utasításban megadva), valamint egy vagy több use utasítás alkothat egy fordítási egységet. Vegyük észre, hogy az Ada csomagok specifikációja és törzse külön fordítási egységként készíthető el. A C és C++ nyelvben a fordítási egység egy darab c, illetve cpp forrásfájlból az előfordító végrehajtásával keletkező forráskód. Könyvtári egység (library unit) Egy önállóan fordítható programegység. Általában egy fordítási egységet (bizonyos nyelvek terminológiájában: modult) értünk alatta, de például az Adában, amikor egy csomagot könyvtári egységként készítünk el (azaz nem ágyazzuk be másik programegységbe), akkor két fordítási egységet írunk: egyet a csomag specifikációjának, egyet pedig a csomag törzsének.

17 16 Programszerkezet Egy Ada program egy vagy több programegységből áll A programegységek többnyire külön fordíthatóak (könyvtári egység) A programegységek egymásba ágyazhatók (blokkszerkezet) Programegység és fordítási egység egység. nem csak logikailag, hanem technikailag is darabolható a program könyvtárak: újrafelhasználhatóság Programegységek felépítése A programegység részei információt, ami más egységek felé látható kell legyen örzs tartalmazza az implementációs részleteket -- ez rejtett más programegységek felé. A törzs részei deklarációs rész programegység végrehajtásának hatását. A programegység részei: példa with Text_IO; procedure Hello is --<-specifikáció Text_IO.Put_Line("Hello"); --<-törzs end Hello; Deklarációs rész (hibaesemények (exception)), programegységek definiálása Változódeklaráció: állapottér megadásához azonosító: típus N: Natural; B: Boolean := True; -- Kezdőérték: érdemes, ha értelmes I, J: Integer; - Több azonosítóhoz ugyanaz a típus (és esetleg kezdőérték) A, B: Positive := 3;

18 Programegységek fajtái, melyik mire való. Az Ada programegységei az alprogramok: végrehajtható algoritmusokat definiálnak, két fajtájuk van: az eljárás: egy tevékenység-sorozat leírása, lehetnek paraméterei a függvény: egy érték kiszámítása és visszaadása a csomagok: logikailag kapcsolatban álló entitások (alprogramok, típusok, konstansok és változók) gyűjteményeit definiálják a sablon (generic) egységek: típussal és alprogrammal is paraméterezhető, makrószerű csomagot vagy alprogramot jelentenek a taszkok: párhuzamosan végrehajtható számításokat definiálnak. a védett egységek: feladatuk a taszkok között megosztott adatok védett használatának koordinálása. 17 Könyvtári egységek, hivatkozás egymásra. Főprogram Egy paraméter nélküli eljárás Hivatkozás használt könyvtárakra with Text_IO; procedure Hello is Text_IO.Put_Line("Hello"); end Hello; Könyvtári egység Külön fordított programegység Az Adában: 1 vagy 2 fordítási egység pl. alprogram versus csomag Újrafelhasználhatóság Szabványos könyvtárak, saját könyvtárak Fordítási egység a C/C++ nyelvekben Amit az előfordító előállít egy forrásfájlból más forrásfájlok beillesztése makrók feldolgozása Tipikusan: egy.c, illetve.cpp fájlba bekerülnek a hivatkozott (#include) fejállományok Globális változók, függvények, osztálydefiníciók, sablondefiníciók sorozata Fordítási egység az Adában Például a főprogram Egy (paraméter nélküli) eljárás + a használt könyvtárak megnevezése (with utasítás) Általában is lehet egy alprogram programegység definíciója a kapcsolatok megadásával with Text_IO; procedure Kiír( S: String ) is return Natural is Text_IO.Put_Line(S); end Kiír; function Négyzet( N: Integer ) return N ** 2; end Négyzet; Program több fordítási egységből with Ada.Integer_Text_IO,with Négyzet; procedure Kilenc is Ada.Integer_Text_IO.Put( Négyzet(3) ); end Kilenc; function Négyzet( N: Integer ) return Integer is return N ** 2; end Négyzet;

19 18 Egymásba ágyazás. Minősített nevek. Fordítási egységek kapcsolatai Ada: with utasítás a fordító ellenőrzi, mit, hogyan használunk például a használt alprogram paraméterezése C++:? közösen használt fejállományok (.h) csúf szerkesztési hibák könnyebb hibát véteni Más nyelvek: export/import lista: Programegység beágyazása Ha nem akarom külön fordítani a használt programegységet, vagy könyvtári egységet csinálok a programegységből, vagy beágyazom. Ada: bármilyen programegységet bármilyen programegységbe ALGOL 60 (blokkszerkezetes nyelv) Programegység beágyazása: Mire jó a beágyazás? Ha egy programegység hatókörét szűkre akarjuk szabni (lokális, nem globális) Speciális, nem akarjuk újrafelhasználhatóvá tenni - logikai indok - olvashatóság - egységbe zárás - bonyolultság kezelése Hatékonysággal kapcsolatos indokok with Ada.Integer_Text_IO; procedure Kilenc is function Négyzet( N: Integer ) return Integer is return N ** 2; end Négyzet; Ada.Integer_Text_IO.Put( Négyzet(3) ); end Kilenc; Minősítő nevek: A GNAT specialitásai Minden fordítási egységet külön fájlba kell írni a fájl neve megegyezik a programegység nevével Csomag specifikációja:.ads Csomag törzse (body):.adb Alprogram:.adb A use utasítás Csomag használata: a komponenseit használjuk Minősített névvel Text_IO.Put_Line("Hello"); A minősítés elhagyható, ha: use Text_IO; Csak csomagra alkalmazható Pascal with utasítása: rekordok komponenseit

20 7) Alprogramok, végrehajtási verem, aktivációs rekord. Blokkszerkezetesség. Closure. 19 végrehajtási verem, aktivációs rekord. Végrehajtási verem execution stack Az alprogramhívások tárolására Az éppen végrehajtás alatt álló alprogramokról aktivációs rekordok A verem teteje: melyik alprogramban van az aktuálisan végrehajtott utasítás A verem alja: a főprogram Egy alprogram nem érhet véget, amíg az általa hívott alprogramok véget nem értek Dinamikus (hívási) lánc Aktivációs rekord Activation record, stack frame Egy alprogram meghívásakor bekerül egy aktivációs rekord a verembe Az alprogram befejeződésekor kikerül az aktivációs rekord a veremből Rekurzív alprogram: több aktivációs rekord Az aktivációs rekord tartalma: paraméterek, lokális változók, egyebek Blokkszerkezetes statikus hatókörű nyelvek esetén: tartalmazó alprogram Automatikus változók A végrehajtási veremben A blokkok (alprogramok, blokk utasítások) lokális változói ha nem static Automatikusan jönnek létre és szűnnek meg a blokk végrehajtásakor A hatókörhöz igazodó élettartam Rekurzió: több példány is lehet belőlük Alprogramok, Kivételek A végrehajtási verem kiürítése stack trace Vezérlésátadás kivételes esetek kezelésénél Kivétel: eltérés a megszokottól, az átlagostól Programhiba (dinamikus szemantikai hiba) pl. tömb túlindexelése Speciális eset jelzése Kiváltódás, terjedés, lekezelés, definiálás, kiváltás Alprogramok az alprogramok: végrehajtható algoritmusokat definiálnak Programegység Végrehajtás kezdeményezése: meghívással két fajtájuk van: az eljárás: egy tevékenység-sorozat leírása, lehetnek paraméterei a függvény: egy érték kiszámítása és visszaadása Eljárások és függvények Eljárások:ADA:procedure:Az eljárások általában a változók által kifeszített téren (állapottéren) vagy a program környezetén elvégzendő transzformációkat adnak meg. Függvények:ADA:function: A függvények valamilyen értéket állítanak elő, de Transzformációt nem végeznek. Sem a program változóinak értékére, sem a program környezetére nincsenek semmilyen hatással: a függvényeknek nincs mellékhatásuk. (Elméletben!) Az üres utasítás Üres -end nem írható Más szituációkban is használjuk Ezt a kulcsszót nem csak utasításként használjuk procedure Semmi is null; end;

21 Alprogramok hívása és a return Alprogramokat nevük és aktuális paramétereik megadásával hívhatunk. Text_IO.Put_Line("Kiírandó szöveg"); Text_IO.Get(Ch); -- ahol Ch egy karakter típusú változó Text_IO.New_Line; A return utasítás hatására az alprogram végrehajtása befejeződik. Függvénynél itt adjuk meg az eredményét is: return X+Y; 20 Paraméterek, visszatérési érték Információ átadása / átvétele alprogramhívásnál: paramétereken keresztül visszatérési értéken keresztül nem-lokális változón keresztül Paramétereknél: az információ áramlása Merre: a paraméterek módja (Ada) Hogyan: a paraméterátadás technikája (paraméterátadás módja) Alprogram hívásakor a formális paramétereknek aktuális paramétereket feleltetünk meg. Visszatérés: return A függvények visszatérési értékét és annak típusát a return kulcsszó után kell megadni. A típusra nincs megkötés A függvénynek tartalmaznia kell (egy vagy több) return utasítást is. (Program_Error, ha nem azzal ér véget!) Paraméter nélküli return utasítás eljárásokban állhat: hatására az eljárás véget ér. Mit lehet tenni velük() Egy in típusú formális paraméternek nem adhatunk értéket, csak olvashatjuk. Egy out módú paramétert lehet írni, és ha már kapott valamilyen értéket az alprogramon belül, lehet olvasni is. Egy in out módú paraméter értékét olvashatjuk és írhatjuk is. Blokkszerkezetesség. Blokkszerkezetes nyelv (block-structured) Olyan nyelv, amelyben az alprogramok egymásba ágyazása megengedett. (Tipikusan a Pascal jellegű nyelvek ilyenek, például az Ada és a Modula-2.) Nem szokták blokkszerkezetesnek nevezni azokat a nyelveket, amelyekben alprogramok nem, csak blokk utasítások (például C), vagy az alprogramtól különböző programegységek (C++, Java) ágyazhatók egymásba. A programegységek egymásba ágyazhatók (blokkszerkezet) Függvénybe függvény nem ágyazható Nem nevezzük blokkszerkezetesnek Blokkszerkezetes nyelvek Alprogramot beágyazhatunk alprogramba Ilyen: Algol 60, Pascal, Ada, Haskell Nem ilyen: C, C++, Java(!)

22 Blokkok és hatókör Egy blokk deklarációinak hatóköre a deklarációtól a blokk végéig tart Beleértve a beágyazott blokkokat is 21 procedure A is procedure B is end; declare procedure C is end; declare end; end; end; procedure A is procedure B is end; declare procedure B is end; end; end; Lokális és nonlokális deklaráció Egy blokkban elhelyezett deklaráció lokális (local) a blokkra nézve A blokkon kívülről nem hivatkozható Egy külső blokkban elhelyezett deklaráció nonlokális (non-local) a befoglalt blokkok számára Alternatív elnevezés: globális a befoglalt blokkra nézve declare X: Float; declare end; end; Globális deklaráció az egész programra vonatkozik A hatóköre az egész program abszolút int glo; void f ( int par ) { int loc = par; glo = loc; } procedure A is N: Integer; Put("Hány adat lesz?"); Get(N); declare T: array (1..N) of Integer; -- beolvasás és feldolgozás end; end; Egy másik haszon Ha egy nagy tárigényű változót csak rövid ideig akarok használni Egy blokk utasítás lokális változója Ada: kivételkezelés Closure. Az alprogramra mutató típus használatával csak könyvtári szinten megvalósított alprogramok adhatók át Sablon esetén nincs ilyen megkötés Viheti magával a környezetét Ez jobban hasonlít a lezárt (closure) átadására,???

23 8) Alprogramok és operátorok túlterhelése, átdefiniálása. 22 Alprogramnevek túlterhelése Overloading Ugyanazzal a névvel több alprogram Különböző legyen a szignatúra A fordító a hívásból eldönti, hogy melyiket kell meghívni Ha egyik sem illeszkedik: fordítási hiba Ha több is illeszkedik: fordítási hiba Ha ugyanazt a tevékenységet különböző paraméterezéssel is el akarjuk tudni végezni Példák C++ és Ada nyelven int max ( int x, int y ) { return x > y? x : y; } int max ( int x, int y, int z ) { return max(x, max(y,z)); } int x = max( 50*62, 51*60, 52*61 ); function Max ( X, Y: Integer ) return Integer is if X > Y then return X; else return Y; end if; end; function Max ( X, Y, Z: Integer ) return Integer is return Max(X, Max(Y,Z)); end; X: Integer := Max( 50*62, 51*60, 52*61 ); Szignatúra C++: a név és a formális paraméterek száma és típusa Ada: a név, a formális paraméterek száma és típusa, valamint a visszatérési típus túl lehet terhelni a visszatérési értéken nem lehet egy függvényt úgy hívni, hogy semmire sem használjuk a visszatérési értékét Különböző szignatúra procedure A; procedure A ( I: in out Integer ); procedure A ( S: String ); function A return Integer; function A return Float; procedure A ( V: Natural := 42 ); -- nem jó Híváskor a többértelműség feloldandó package Igék is type Ige is ( Sétál, Siet, Vár ); procedure Kiír ( I: in Ige ); end Igék; package Főnevek is type Főnév is ( Ház, Palota, Vár ); procedure Kiír ( F: in Főnév ); end Főnevek; use Igék, Főnevek; Kiír( Vár ); -- ford. hiba Igék.Kiír( Vár ); Kiír( Ige (Vár) ); Kiír( I => Vár ); 7/42

24 23 Operátorok túlterhelése Mind a C++, mind az Ada nyelvben lehet C++-ban több operátor van (pl. () vagy =) Az Adában nem minden operátort lehet túlterhelni (nem lehet: in, not in, and then, or else) Egyes nyelvekben csak közönséges alprogramokat (Java), vagy még azt sem (ML) De a predefinit operátorok általában túlterheltek (+) Egyes nyelvekben lehet új operátorokat is definiálni (ML, Clean stb.) fixitás, precedencia, asszociativitás megadásával Operátorok túlterhelése Adában function "*" ( A, B: Vektor ) return Real is S: Real := 0.0; for I in A'Range loop S := S + A(I) * B(I); end loop; return S; end "*"; R := P * Q; R := "*"(P,Q); Alprogram, mint típusművelet Beépített típusok: operátorok, attribútumok Származtatott típusok: megöröklik ezeket Programozó által definiált típusok Tipikusan: átlátszatlan típus Absztrakt értékhalmaz és műveletek Ezek a műveletek is örökölhetők Primitív műveletek A típus megadása után felsorolt alprogramok Vagy valamelyik paraméter, vagy a visszatérési érték olyan típusú Tipikusan: egy csomagban definiálok egy (általában átlátszatlan) típust a műveleteivel Származtatott típusok: megöröklik a primitív műveleteket Felüldefiniálás Egy típusra felüldefiniálhatjuk az előre definiált és a megörökölt műveleteket (Előre definiált) operátorok Primitív alprogramok Más implementációt rendelhetünk hozzájuk Ez különbözik a túlterheléstől

25 Példa primitív műveletre package Queues is type Queue( Capacity: Positive ) is limited private; procedure Hiext ( Q: in out Queue; E: in Element ); procedure Lopop ( Q: in out Queue; E: out Element ); private end Queues; 24 Példa öröklésre with Queues; use Queues; package Dequeues is type Dequeue is new Queue; procedure Loext ( Q: in out Dequeue; E: in Element ); procedure Hipop ( Q: in out Dequeue; E: out Element ); end Dequeues; Túlterhelés és felüldefiniálás package Racionálisok is type Racionális is private; function "+" ( P, Q: Racionális ) return Racionális; --túlterhelés function "=" ( P, Q: Racionális ) return Boolean; -- fellüldefiniálás private type Racionális is record Számláló: Integer; Nevező: Positive; end record; end Racionálisok;

26 9) Függvény és eljárás fogalmi különbsége. Paraméterek alapértelmezett értéke. Alprogram paramétereinek lehetséges módjai. Formális és aktuális paraméter. 25 Függvény és eljárás fogalmi különbsége. az alprogramok: végrehajtható algoritmusokat definiálnak Programegység Végrehajtás kezdeményezése: meghívással két fajtájuk van: az eljárás: egy tevékenység-sorozat leírása, lehetnek paraméterei a függvény: egy érték kiszámítása és visszaadása Eljárások és függvények Eljárások:ADA:procedure:Az eljárások általában a változók által kifeszített téren (állapottéren) vagy a program környezetén elvégzendő transzformációkat adnak meg. Függvények:ADA:function: A függvények valamilyen értéket állítanak elő, de Transzformációt nem végeznek. Sem a program változóinak értékére, sem a program környezetére nincsenek semmilyen hatással: a függvényeknek nincs mellékhatásuk. (Elméletben!) Alprogramok hívása és a return Alprogramokat nevük és aktuális paramétereik megadásával hívhatunk. Text_IO.Put_Line("Kiírandó szöveg"); Text_IO.Get(Ch); -- ahol Ch egy karakter típusú változó Text_IO.New_Line; A return utasítás hatására az alprogram végrehajtása befejeződik. Függvénynél itt adjuk meg az eredményét is: return X+Y; Paraméterek, visszatérési érték Információ átadása / átvétele alprogramhívásnál: paramétereken keresztül visszatérési értéken keresztül nem-lokális változón keresztül Paramétereknél: az információ áramlása Merre: a paraméterek módja (Ada) Hogyan: a paraméterátadás technikája (paraméterátadás módja) Alprogram hívásakor a formális paramétereknek aktuális paramétereket feleltetünk meg. Visszatérés: return A függvények visszatérési értékét és annak típusát a return kulcsszó után kell megadni. A típusra nincs megkötés A függvénynek tartalmaznia kell (egy vagy több) return utasítást is. (Program_Error, ha nem azzal ér véget!) Paraméter nélküli return utasítás eljárásokban állhat: hatására az eljárás véget ér. Mit lehet tenni velük() Egy in típusú formális paraméternek nem adhatunk értéket, csak olvashatjuk. Egy out módú paramétert lehet írni, és ha már kapott valamilyen értéket az alprogramon belül, lehet olvasni is. Egy in out módú paraméter értékét olvashatjuk és írhatjuk is.

27 26 Paraméterek alapértelmezett értéke procedure Animals(Total : in out INTEGER; Cows : in INTEGER := 0; Pigs : in INTEGER := 0; Dogs : in INTEGER := 0); In értékeknek lehet, ilyenkor kevesebb paraméterrel is meghívható a függvény. Csak az utolsó értékeknek lehet alapértelmezett értékük. Paraméter alapértelmezett értéke alapértelmezett érték adható meg megfeleltetni neki C++ esetében: csak érték szerintinél Paraméterek típusa Az aktuális és a formális paraméter típusának meg kell egyeznie fordítás közben ellenőrzött Paraméterátadáskor ellenőrzésre kerül az is, hogy az átadott értékek megfelelnek-e az altípusmegszorításoknak. futási időben ellenőrzött Mi lehet aktuális paraméter: Egy in paraméternek átadhatunk egy tetszőleges kifejezést (például egy változót is): a kifejezés értéke lesz az aktuális paraméter. Egy out vagy in out paraméterként viszont csak egy balértéket (pl. változót) adhatunk át: ebbe a balértékbe kerül majd az alprogram által kiszámított érték (illetve in out mód esetén ez a balérték tartalmazza a bemenő paraméterértéket is). Paraméter alapértelmezett módja: in procedure Egyenest_Rajzol ( Kezdôpont, Végpont: Pont ) Mindkét paraméter in módú Eljárásoknál inkább írjuk ki... Függvényparaméterek módja Függvények formális paramétere csak in módú lehet! Csak számoljon ki egy értéket, és adja vissza Nem is szoktuk kiírni az in szócskát... Formális és aktuális paraméter Formális és aktuális paraméter: - Függvények formális paramétere csak in módú lehet Formális paraméter: az a paraméter, melynek helyére az aktuális paramétert helyettesítjük, függvényhívás esetén. Aktuális paraméter: Függvényhívásnál a függvény egy paraméterének átadott, érték. A függvény ennek az értéknek a segítségével hajtja végre az adott feladatot.

28 10) Deklaráció és definíció. Hatókör, láthatóság, kiterjesztett láthatóság. Deklaráció (declaration) Egy entitás (programegység, változó, típus stb) és egy név összekapcsolása. A deklaráció bejelenti, hogy a továbbiakban az adott név az adott entitást jelöli, és megbízza a fordítót, hogy az adott nevet ne engedje másképp használni, csak az entitásnak megfelelően. (Az Adában a nevet nem egy entitáshoz, hanem annak egy nézetéhez rendelhetjük, így további, az adott nézetre vonatkozó megszorítások betartatására kérhetjük a fordítót.) 27 Definíció Változó/alprogram/típus/csomag létrehozása. Változók definiálása történhet például változódeklaráció segítségével. Nem minden változódeklaráció definiál új változót. Például C-ben: extern int foo; Vagy C++ban: int i = 2, &j = i; Típus definiálása során új típus jön létre. A C/C++ typedef utasítása típust deklarál, de nem definiál. Fontos a structural és named típusekvivalencia közötti különbség. Alprogramok deklarálhatók úgy, hogy a definíciót csak később biztosítjuk hozzájuk. (Pascal, C, C++, Ada példák...) Deklaráció hatóköre (scope) A programszöveg azon része, amelyre nézve a deklaráció érvényben van, azaz a deklarációban szereplő név és entitás össze van kapcsolva egymással. A legtöbb nyelvben statikus hatóköri szabályok vannak, azaz a hatókör a programszöveg egy szintaktikusan egybefüggő része. A deklaráció hatóköre tipikusan a deklarációtól kezdődik, és a deklarációt közvetlenül tartalmazó blokk végéig tart. Deklaráció láthatósága (visibility) A programszöveg azon része, amelyre nézve a deklarációban szereplő név a deklarációban szereplő entitást jelenti. Nem feltétlenül esik egybe a deklaráció hatókörével, lehet, hogy csak egy része annak. Előfordulhat, hogy a programszöveg egy pontján két olyan deklaráció hatókörében vagyunk, melyek ugyanazt a nevet rendelik két különböző entitáshoz. Ilyenkor a "közelebbi" deklaráció szokott látható lenni, azaz a közelebb deklarált entitásra hivatkozhatunk a névvel. Úgy is mondjuk, hogy a közelebbi deklaráció elfedi, eltakarja (hides) a távolabbi deklarációt. Jellemző példa: sok nyelvben egy beágyazó és egy beágyazott blokkban deklarálhatunk azonos névvel változókat. A beágyazott (belső) blokkban szereplő deklaráció elfedi a külső blokkban szereplő deklarációt. Bizonyos esetekben minősítés segítségével az elfedett entitáshoz is hozzá lehet férni. Az ilyen kiterjesztett láthatóságra a blokkszerkezetes nyelvekben láthatunk példát: ha egy blokkot beágyazunk az A programegységbe, és a blokkban egy deklarációval elfedjük az A-ban x névvel deklarált entitást, akkor az A.x minősített névvel továbbra is hozzáférhetünk az elfedett entitáshoz. Deklaráció elfedése (hiding) Ha egy deklaráció hatókörében a deklarációban szereplő névvel egy másik entitást is deklarálunk, akkor az első deklaráció név-entitás összekapcsolását elfedtük. (Lásd még: deklaráció láthatósága.) Deklaráció deklaráció: egy objektumhoz hozzárendel egy nevet változó: a deklaráció egy konkrét memóriaterületet azonosít, amelynek megváltozhat a tartalma hatókör vagy láthatósági tartomány (scope): a programszöveg azon összefüggő része, ahol a deklaráció által bevezetett név használatban van lokális név: függvényen vagy blokkon belül bevezetett név, hatóköre a deklaráció helyétől a blokk (a függvény blokkja) végéig tart globális név: függvényen, osztályon, névtéren kívül bevezetett név, hatóköre a deklaráció helyétől a tartalmazó fájl végéig tart Deklaráció láthatósága közvetlen láthatóság: a deklarációra egyetlen azonosítóval (műveleti jellel) lehet hivatkozni láthatóság: a deklaráció közvetlenül vagy minősítéssel (::operátor) látható

29 using: név közvetlenül láthatóvá tétele másik névtérből vagyosztályból átlapolás vagy elfedés (overlapping): a programszöveg egy részén több, azonos nevet bevezető deklaráció látható Deklaráció láthatósága elfedett lokális név nem használható hatóköre azonban itt is tart a függvényparamétereket nem lehet elfedni a függvény törzsében (de a függvény törzsén belüli blokkban már igen) 28 Változódeklaráció: állapottér megadásához azonosító: típus N: Natural; B: Boolean := True;-- Kezdőérték: érdemes, ha értelmes I, J: Integer; -- Több azonosítóhoz ugyanaz a típus (és esetleg kezdőérték) A, B: Positive := 3; --Mire való a típus? objektumok deklarációja: N: Integer; - kezdeti értéket is adhatunk: N: Integer := 42; - konstanst is deklarálhatunk: Max: constant Integer := 100; N_Vessző: constant Integer := N; Diszkrimináns alapértelmezett értéke subtype Méret is Natural range ; type Szöveg_D( Hossz: Méret := 10 ) isrecord Érték: String(1.. Hossz); Pozíció: Natural := 0; end record ; Sz_1: Szöveg_D(10); Sz_2: Szöveg_D; Mire jó, ha van? létrehozásakor adni az objektumok alapértelmezett értéket - az egész rekordra vonatkozó értékadással - változtatható. változtatható meg! Az altípus nem változhat