tételsor a programozási nyelvek (ada) tárgyhoz 1-10e1si%20nyelvek... · kifejezések...
TRANSCRIPT
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!
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.
2
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
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
Programozási Nyelvek ADA Tételsor Kidolgozás 1-10
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
Programozási Nyelvek ADA Tételsor Kidolgozás 1-10
Készítette: Cselyuszka Alexandra
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
5
Programozási Nyelvek ADA Tételsor Kidolgozás 1-10
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
Programozási Nyelvek ADA Tételsor Kidolgozás 1-10
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
Programozási Nyelvek ADA Tételsor Kidolgozás 1-10
Készítette: Cselyuszka Alexandra
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
Programozási Nyelvek ADA Tételsor Kidolgozás 1-10
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.
9
Programozási Nyelvek ADA Tételsor Kidolgozás 1-10
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
Programozási Nyelvek ADA Tételsor Kidolgozás 1-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
Programozási Nyelvek ADA Tételsor Kidolgozás 1-10
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
Programozási Nyelvek ADA Tételsor Kidolgozás 1-10
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;
13
Programozási Nyelvek ADA Tételsor Kidolgozás 1-10
Készítette: Cselyuszka Alexandra
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
with Ada.Integer_Text_IO;
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
Programozási Nyelvek ADA Tételsor Kidolgozás 1-10
Készítette: Cselyuszka Alexandra
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
Programozási Nyelvek ADA Tételsor Kidolgozás 1-10
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
Programozási Nyelvek ADA Tételsor Kidolgozás 1-10
Készítette: Cselyuszka Alexandra
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
Programozási Nyelvek ADA Tételsor Kidolgozás 1-10
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
Ada.Integer_Text_IO.Put(
Négyzet(3) );
end Kilenc;
function Négyzet( N: Integer )
return Integer is
begin
return N ** 2;
end Négyzet;
18
Programozási Nyelvek ADA Tételsor Kidolgozás 1-10
Készítette: Cselyuszka Alexandra
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
begin
return N ** 2;
end Négyzet;
begin
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
19
Programozási Nyelvek ADA Tételsor Kidolgozás 1-10
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:
– 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 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
Programozási Nyelvek ADA Tételsor Kidolgozás 1-10
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
Programozási Nyelvek ADA Tételsor Kidolgozás 1-10
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
Programozási Nyelvek ADA Tételsor Kidolgozás 1-10
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
Programozási Nyelvek ADA Tételsor Kidolgozás 1-10
Készítette: Cselyuszka Alexandra
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
Programozási Nyelvek ADA Tételsor Kidolgozás 1-10
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
Programozási Nyelvek ADA Tételsor Kidolgozás 1-10
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:
– 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.
26
Programozási Nyelvek ADA Tételsor Kidolgozás 1-10
Készítette: Cselyuszka Alexandra
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
Programozási Nyelvek ADA Tételsor Kidolgozás 1-10
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
Programozási Nyelvek ADA Tételsor Kidolgozás 1-10
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