Tételsor a Programozási nyelvek (Ada) tárgyhoz 1-10e1si%20nyelvek... · Kifejezések kiértékelése szekvencia pont: a programkód azon pontjai, amelyekhez érkezve garantált,

0

Programozási Nyelvek ADA Tételsor Kidolgozás 1-10

Készítette: Cselyuszka Alexandra

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

Légy szíves ha hibát találtok benne, vagy hozzá tudnátok rakni valamit akkor írjatok nekem!

[email protected]

Első feltöltve: 2013.01.24

felhasznált anyagok:

1.

http://www.fuvesi.com/programozas/nyelvi_elemek.html

http://lexybunnyy.web.elte.hu/elte/felev5/programozasi_nyelvek_ada/gyakorlatok/adaGY_20121005.ada

http://kitlei.web.elte.hu/segedanyagok/foliak/c++/c++02.html 3. http://nyelvek.inf.elte.hu/leirasok/Tom/index.php?chapter=4

http://digitus.itk.ppke.hu/~totmaga/prog/ppke_bp/gyakorlati_anyagok_bp2/ppke_bp2_gy09_eml.pdf

5.

http://wiki.prog.hu/wiki/Strukt%C3%BAr%C3%A1lt_programoz%C3%A1s

6.

http://codenet.hu/forum/index.php?topic=4281.0

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.

mailto:[email protected]

http://www.fuvesi.com/programozas/nyelvi_elemek.html

http://lexybunnyy.web.elte.hu/elte/felev5/programozasi_nyelvek_ada/gyakorlatok/adaGY_20121005.ada

http://kitlei.web.elte.hu/segedanyagok/foliak/c++/c++02.html

http://nyelvek.inf.elte.hu/leirasok/Tom/index.php?chapter=4

http://digitus.itk.ppke.hu/~totmaga/prog/ppke_bp/gyakorlati_anyagok_bp2/ppke_bp2_gy09_eml.pdf

http://wiki.prog.hu/wiki/Strukt%C3%BAr%C3%A1lt_programoz%C3%A1s

http://codenet.hu/forum/index.php?topic=4281.0

1


Készítette: Cselyuszka Alexandra Tartalom:

-

2


Készítette: Cselyuszka Alexandra Tételsor a Programozási nyelvek (Ada) tárgyhoz 1-10

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

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

begin

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;

begin

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 )

3


Készítette: Cselyuszka Alexandra 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

2

() Csoportosítás

Bal

(a)

Nem

Nem

[] Tömb-elérés a[] Igen

-> Mutatón keresztüli tag-

elérés ptr->b() Igen

. Objektumon keresztüli tag-

elérés a.b() Nem

++ Posztfix növelés a++ Igen

-- Posztfix csökkentés a-- Igen

3

! Logikai tagadás

Jobb

!a

Nem

Igen

~ Bitenkénti negálás ~a Igen

++ Prefix növelés ++a Igen

-- Prefix csökkentés --a Igen

- Előjel - -a Igen

+ 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

4 ->* Tagkiválasztás

mutatón/objektumon Bal

a->*b() Igen

Igen

.* a.*b() Nem

5

* Szorzás

Bal Infix Nem Igen / Osztás

% Maradékszámítás

6 + Összeadás

Bal Infix Nem Igen - Kivonás

7 << Bitenkénti eltolás balra

Bal Infix Nem Igen >> Bitenkénti eltolás jobbra

8

< Kisebb

Bal Infix Nem Igen <= Kisebb-egyenlő

> Nagyobb

>= Nagyobb-egyenlő

9 == Egyenlő

Bal Infix Nem Igen != Nemegyenlő

10 & Bitenkénti ÉS Bal Infix Nem Igen

11 ^ Bitenkénti kizáró VAGY Bal Infix Nem Igen

12 | Bitenkénti megengedő

VAGY Bal Infix Nem Igen

13 && Logikai ÉS Bal Infix Nem Igen

14 || Logikai(megengedő)

VAGY Bal Infix Nem Igen

15 ? : if-then-else operátor Jobb

logikai-kif ?

kifejezés :

kifejezés

Nem Nem

16

= Értékadás

Jobb Infix Nem Igen

+= Ö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

&= Bitenkénti ÉS és értékadás

^= Bitenkénti kizáró VAGY és

é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

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

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

http://kitlei.web.elte.hu/segedanyagok/foliak/c++/c++02.html#konstruktor

5


Készítette: Cselyuszka Alexandra 2) Értékadás. Értékadás összetett típusokra. Korlátozott típusok.

- 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 ( 1..10 ) 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: -2147483648

6


Készítette: Cselyuszka Alexandra É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);

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

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;

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.

8


Készítette: Cselyuszka Alexandra 3) Sekély és mély másolás, illetve összehasonlítás.

http://hu.scribd.com/doc/58372488/24/Objektumok-duplikalasa-es-osszehasonlitasa

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

http://hu.scribd.com/doc/58372488/24/Objektumok-duplikalasa-es-osszehasonlitasa

9


Készítette: Cselyuszka Alexandra 4) Memóriaszivárgás. Az Ada Controlled típusai.

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

}

10


Készítette: Cselyuszka Alexandra 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

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;

begin

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;

begin

Int_Sorok.Betesz(S,1);

end B;

begin

B; B; B; B; B; B; B; B; B; B; B; B; B; B;

…

end A;

11


Készítette: Cselyuszka Alexandra 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

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

12


Készítette: Cselyuszka Alexandra 5) Strukturált és nem strukturált vezérlési szerkezetek. Az if-then-else probléma (avagy csellengő

else).

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

Pascal stb.

le van zárva

if (a>0)

if (b>0) c = 1;

else c = 0

Elágazás: case (1)

break-kel

jár

felhasználási

területei

utasítással

is

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;

http://wiki.prog.hu/wiki/Vez%C3%A9rl%C3%A9si_szerkezet

http://wiki.prog.hu/wiki/El%C3%A1gaz%C3%A1s

http://wiki.prog.hu/wiki/Ciklus

http://wiki.prog.hu/wiki/Programoz%C3%A1si_nyelvek

http://wiki.prog.hu/wiki/C

http://wiki.prog.hu/wiki/Pascal

http://wiki.prog.hu/wiki/Ada

13



case (X mod 20) + 1 is

when 1..3 | 5 | 7 | 11 | 13 | 17 | 19 =>

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


procedure Tízig is

begin

for I in 1..10 loop

Ada.Integer_Text_IO.Put(I);

end loop;

end Tízig;

rvallum: ciklusmag nem hajtódik

végre

for I in reverse 1..10 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;

begin

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

loop

...

end loop;

A blokk utasítás

Tartalmazhat újabb deklarációkat <utasítások>

declare

<deklarációk>

begin

<utasítások>

end;

<utasítások>

A blokk utasítás: beágyazás …

declare

…

begin

…

declare … begin … end;

…

end;

…

14



A blokk utasítás:

Mikor van rá szükség?

rövid szakaszán

– részben kiváltható mutatókkal

dől el, deklarálás előtt ki kell számolni

– 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

köthető a kiugrás

ciklust is

loop

…

exit;

…

end loop;

------------------------------

loop

loop

Get(Ch); …

exit when Ch = ‘q’;

exit when <felt.>

…

end loop;

end loop;

------------------------------

A: for I in 1..10 loop

for J in 1..10 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

15


Készítette: Cselyuszka Alexandra 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.

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.

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ó

begin

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;

17


Készítette: Cselyuszka Alexandra 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.

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

begin

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

begin

Text_IO.Put_Line(S);

end Kiír;

function Négyzet( N: Integer )

begin

return N ** 2;

end Négyzet;

Program több fordítási egységbőlwith Ada.Integer_Text_IO,with

Négyzet;

procedure Kilenc is

begin


Négyzet(3) );

end Kilenc;


return Integer is

begin

return N ** 2;

end Négyzet;

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


procedure Kilenc is


return Integer is

begin

return N ** 2;

end Négyzet;

begin


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

19


Készítette: Cselyuszka Alexandra 7) Alprogramok, végrehajtási verem, aktivációs rekord. Blokkszerkezetesség. Closure.

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

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,

Alprogramok

az alprogramok:

végrehajtható algoritmusokat definiálnak

Programegység

Végrehajtás kezdeményezése: meghívással

két fajtájuk van:



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 begin-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

begin

null;

end;

20


Készítette: Cselyuszka Alexandra 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.

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(!)…

21


Készítette: Cselyuszka Alexandra 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

procedure A is

procedure B is … begin … end;

begin

declare

procedure C is … begin …

end;

begin

declare … begin … end;

end;

end;

procedure A is

procedure B is … begin … end;

…

begin…

declare…

procedure B is … begin …

end;

…

begin

…

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; begin declare … begin … 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;

begin

Put("Hány adat lesz?");

Get(N);

declare

T: array (1..N) of

Integer;

begin

-- 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,

???

22


Készítette: Cselyuszka Alexandra 8) Alprogramok és operátorok túlterhelése, átdefiniálása.

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

begin

if X > Y then return X;

else return Y;

end if;

end;

function Max ( X, Y, Z: Integer )

return Integer is

begin

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

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;

begin

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

24


Készítette: Cselyuszka Alexandra 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;

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;

25


Készítette: Cselyuszka Alexandra 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.

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:



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.

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ípus-

megszorí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.

27


Készítette: Cselyuszka Alexandra 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.)

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ó

28


Készítette: Cselyuszka Alexandra 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)

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

0..1000;

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?

adni az objektumok

létrehozásakor

alapértelmezett értéket

- az egész rekordra

vonatkozó értékadással - változtatható.

változtatható meg! Az altípus nem változhat

http://kitlei.web.elte.hu/segedanyagok/foliak/c++/c++01.html#osztály-using

Documents

Tételsor a Programozási nyelvek (Ada) tárgyhoz 1-10e1si%20nyelvek... · Kifejezések kiértékelése szekvencia pont: a programkód azon pontjai, amelyekhez érkezve garantált,