Programozás módszertan Alprogramok Pere László ( ) PÉCSI EGYETEM TERMÉSZETTUDOMÁNYI KAR INFORMATIKA ÉS ÁLTALÁNOS TECHNIKA TANSZÉK MAGYAR TUDOMÁNYOS AKADÉMIA SZÁMÍTÁSTECHNIKAI ÉS AUTOMATIZÁLÁI KUTATÓINTÉZET ELEARNING OSZTÁLY Programozás módszertan p.1/110
Bevezetés Programozás módszertan p.2/110
Bevezetés Az alprogramok több szempontból is javítják a szoftverminőséget: Újrafelhasználhatóság. Olvashatóság. Módosíthatóság. Karbantarthatóság. Programozás módszertan p.3/110
Eljárások és függvények Az alprogramokat két csoportba sorolhatjuk: Az eljárások a program környezetén vagy a változókon végeznek módosításokat. A függvények valamilyen értéket számítanak ki, a változókra és a program környezetére nincsenek hatással (nincs mellékhatásuk). Programozás módszertan p.4/110
Kapcsolattartás Programozás módszertan p.5/110
Kapcsolattartás Az alprogramok a számításokat a paraméterként átvett értékeken (bemenő paraméterek) végzik el. A függvények a kiszámított értéket visszatérési értékként adják át. Az eljárások a kimenő paraméterek értékének megváltoztatásával adhatnak vissza értéket (formális és aktuális paraméterek egymáshoz rendelése). Programozás módszertan p.6/110
Eljárások/függvények Sok nyelv (C, C++, Java, C#, CLU) nem tesz különbséget eljárások és függvények közt. Ezekben a nyelvekben minden alprogram függvény. Ezeknél a nyelveknél a visszatérési értéket sokszor figyelmen kívül hagyjuk (eldobjuk). Programozás módszertan p.7/110
Paraméterek típusa Fontos kérdés, hogy egy programozási nyelvben mi lehet paraméter és visszatérési érték. Ezek általában: értékek típusok alprogramok modulok Programozás módszertan p.8/110
a) Tömbök Programozás módszertan p.9/110
Meghatározatlan méretű tömb Sok programozási nyelv megengedi, hogy a formális paraméter nem teljesen meghatározott típusú legyen. Így olyan alprogram készíthető, amely többféle konkrét típussal is használható. E lehetőség tipikus használata a meghatározatlan méretű tömböt kezelő alprogram készítése. Programozás módszertan p.10/110
!. " % #/ - " " $# " & 0 Pascal A Standard Pascalban meghatározatlan méretű tömböt a következő formában adhatunk át: 1 % ')( *,+ " " 1 + " 1 2 + 3)4 " 1 Az alprogramon belül a low és high változók hordozzák a tömb felső és alsó indehatárát. Programozás módszertan p.11/110
Ada Adában a paraméterként átvett tömb felső és alsó indexhatárára attribútumként hivatkozhatunk. Ha az átvett tömb neve V, az alsó indexérték V First, a felső indexérték pedig V Last. Programozás módszertan p.12/110
2. ' 5 5 " 5 5 0 ' 5 5 " 5 6 5 0 C A C programozási nyelvben átadhatjuk a tömböket az első elem címével, a méretüket pedig külön paraméterként. A C szabvány külön foglalkozik a meghatározatlan méretű tömbök kezelésével és megengedi, hogy ilyen tömbök struktúrák elemei legyenek (de csak az utolsó elem lehet meghatározatlan méretű tömb). 1 3)4 2 3)4 Programozás módszertan p.13/110
Java A Java tömbjeinek tárolásakor a méretet is tároljuk, így a tömbök átadása után a méret lekérdezhető a tömbből. Programozás módszertan p.14/110
3 B?D ' B @A ;8 78? C B?> =< :9 0 0 C B?< > = 3 G G 'F B D @? : FORTRAN A FORTRAN 77 lehetővé teszi meghatározatlan méretű tömbök átadását. A méretet külön változóban adjuk át. 1 2 3 E? : A FORTRAN 77 meghatározatlan méretű tömbjei kizárólag paraméterátadásra használhatók, végső soron minden meghatározatlan méretű tömb valamely meghatározott méretű tömb hordozására használható. Programozás módszertan p.15/110
Többdimenziós tömbök Az egydimenziós tömb esetén csak annyit kell tudnunk, hogy nem lépjük át az indexhatárokat, nem feltétlen kell tudnunk, hogy mekkora a tömb pontos mérete. Többdimenziós tömb esetében mindenképpen ismernünk kell a tömb méretét ahhoz, hogy a tömb adott eleméhez hozzáférjünk (címfüggvény). Ha például kétdimenziós tömb esetén nem tudjuk az első index határait, nem tudjuk kiszámítani a második sor címét. Programozás módszertan p.16/110
Java A Java nyelvben a többdimenziós tömbök tömböket tartalmazó tömbök és mivel a tömbök kezelése referenciákon keresztül történik, nem okoz problémát a címfüggvény kezelése. Programozás módszertan p.17/110
Ada Adában a többdimenziós tömbök kezelése hatékony sor vagy oszlopfolytonos tárolással történik. Többdimenziós tömbök esetén a First, Last dimenziószámmal indexelt változataival kérdezhetjük le az alprogramban. Programozás módszertan p.18/110
FORTRAN A FORTRAN esetében a fordító nem fér hozzá a tömb méretéhez, erre azonban a címfüggvény miatt szükség van. FORTRAN nyelven tahát többdimenziós tömbök esetében mindenképpen a helyes méreteket kell átadnia a programozónak. Programozás módszertan p.19/110
H # 2 G G.F 2. ' 5 5 #" 5 0 C/C++ A C és C++ nyelvekben nehézkes a többdimenziós tömbök meghatározatlan méretű tömbként való átadása. A programozó előtt két út áll: vagy megvalósítja a címfüggvényt, vagy csak az oszlopok méretét hagyja definiálatlanul: 1 3)4 Programozás módszertan p.20/110
C/C++! 1 5 ' 6 5 " 0 " #/ 0 $ # 3 2 I 3 0 J 0 K G 4 4 L #" ' K G 4 M " #/ 4 N N 3 5 L #" ' J K G 4 J M $ # 4 N N J 3 6 N K 6 ' 5 " N 6 $ # N J 3 7 " " 4 8 O Programozás módszertan p.21/110
a) Alprogramok Programozás módszertan p.22/110
Alprogramok Sokszor hasznos lehet alprogramoknak paraméterként alprogramot átadni. Jellemző példa lehet a tetszőleges függvényt integráló vagy deriváló alprogram vagy az elemeket sorbarendező általános rendező alprogram (amely a rendezendő tömbön kívül megkapja az elemek összehasonlítására használható függvényt paraméterként). Programozás módszertan p.23/110
Alprogramok Korai programozási nyelvek nem tették lehetővé alprogramok paraméterként való átadását, újabb nyelvek (LISP, ALGOL 60, PL/I, SIMULA 67, ALGOL 68, Pascal, FORTRAN 77, Modula-2, Modula-3) megadják ezt a lehetőséget a programozónak. Néhány más nyelvben alprogramot nem adhatunk át, de a rájuk mutató pointert igen (C, C++, Ada 95). Említésre méltó a JavaScript, ahol nem teszünk különbséget függvények és változók közt, függvény elhelyezhető változóban. Programozás módszertan p.24/110
! 4 L L 4 #/ + 0 0 4 " ( 0 G K K #" L #/ N + Programozás módszertan p.25/110 Pascal " 3 + " + ' # $ L ' 1 " # $ " 3 + " 1 " 5+ P 1 G 4 + 5 P - 1 # + 4 6 3 ' L 5 K + 5 54 K 1 " % 4 1 2 3 4 5 6 7 8 9
! ' % % #/ 0 0 3 % % 0 I G % K I K M #/ / 3 #/ #/ O " O C C nyelven a függvény nevét () jelek nélkül írva a függvényt alkotó utasítások közül az első címét (a függvény címét) kapjuk. P # 3 P # % ' 3 L 6 P # % ' 1 " P # P # 1 P # G 4 5 P # 3 1 ' ' L 4 6 K N 5 4 K N 54 " 1 2 3 4 5 6 7 8 Programozás módszertan p.26/110 9 10
c) Címke Programozás módszertan p.27/110
Címke Bizonyos nyelvekben (ALGOL 60, PL/I, SIMULA 67, ALGOL 68) címkéket is átadhatunk paraméterként. Ez a lehetőség kitűnően használható kivételkezelésre. A címke segítségével megadhatjuk az alprogramnak hol folytatódjon a végrehajtás, ha hiba lépett fel. Programozás módszertan p.28/110
Alprogramok pecifikációja Programozás módszertan p.29/110
Specifikáció Az alprogram specifikációja az az interface, amelyet a hívó program ismer. A hívó számára mellékes, hogy milyen utasításokat tartalmaz az alprogram, számára csak az a lényeges, hogy milyen módon hívható. Az alprogram specifikációja tartalmazza az alprogram típusát (eljárás, függvény), nevét, a paraméterek típusát és a visszatérési érték típusát. Az alprogram specifikációja alapján a fordító ellenőrizheti és lefordíthatja az alprogram hívását, így az alprogram törzse egy másik fordítási egységben is lehet. Programozás módszertan p.30/110
Paraméterek száma Néhány programozási nyelv nem ellenőrzi a paraméterek számát (általában a script nyelvek). Ezen nyelvek esetében tetszőleges számú paraméterrel hívhatjuk az alprogramokat. A legtöbb programozási nyelv ellenőrzi a paraméterek számát, néhányukban többféle paraméterszámmal is hívhatjuk az alprogramokat. Programozás módszertan p.31/110
#" L 6 " $ L " 0 5 C A C programozási nyelvben a... (ellipsis) kifejezéssel jelezhetjük, ha tetszőleges számú paraméterrel szeretnénk hívni az alprogramot (variadic functions). 1 ' $ # 3)4 A paraméterekhez ilyen esetben a va_list, va_start, va_arg, stb. makrókkal férhetünk hozzá. Programozás módszertan p.32/110
I $ P C 6 1 6 % # Q C++ C++ nyelvben azonos néven, különböző paraméterlistával több függvényt is készíthetünk, a fordító pedig eldönti, hogy melyik függvényt kell hívni az adott esetben: 1 " - 2 $ + 3 " - ' $ = $ 3)4 4 " - ' $ " - 3)4 5 " - ')( 3)4 Programozás módszertan p.33/110
D D 8> 5 5 6 " $ " $ L 6 / $ K 0 0 G & SR K C++ Arra is lehetőséget ad a C++, hogy egyes paramétereket elhagyjunk a függvény hívásakor (default érték): 1 ' $ # # - 2 3)4 Ilyen esetben az elhagyható paraméterek a paraméterlista végén találhatók, az azonosítás pedig a sorrend alapján történik. Programozás módszertan p.34/110
Paraméterek típusa Bizonyos nyelvek esetében a fordító nem ellenőrzi azt, hogy a megfelelő típusú paraméterekkel hívtuk-e az alprogramot (pl. FORTRAN 77). A legtöbb modern nyelv ellenőrzi a formális paraméterek és az aktuális paraméterek típusát (FORTRAN 90, Ada, Pascal, Java). Programozás módszertan p.35/110
3 P ' " $ 0 0 I O C A C nyelv eredeti (K&R) változataiban a fordító a paraméterek típusának ellenőrzését nem végezte el. Ezt a változatot használva a függvény szerkezete: 1 2 3 4 5 P 4 Programozás módszertan p.36/110
3 P ' " $ 0 I O C A C későbbi (ANSI) változataiban már ellenőrzi a fordító a paraméterek számát és típusát. Az előző példa modern változata: 1 2 3 4 Ma már mindenki ezt a formát használja, de régi programokban még megtalálható a K&R változat is. Programozás módszertan p.37/110
Paraméterek neve A legtöbb nyelvben a formális paraméterek neve a hívás során nem jut szerephez, az csak az alprogramot író programozó számára lényeges. Ezen nyelvek esetében a paraméterek neve csak megkönnyíti a paraméterek szerepének megértését, a hívást nem befolyásolja. Más nyelvek esetében az aktuális paraméterek nem csak pozíció, hanem név alapján is megfeleltethető a hívás során. Ezen nyelvek esetében a formális paraméterek neve fontos szerepet kaphat a hívás során. Programozás módszertan p.38/110
" $ 6 " 6 " $ $ - 0 C A C programkönyvtár függvényeinek használatát könnyen megérhetjük a formális paraméterek nevének segítségével: 1 $ " ' $ % # 3)4 $ " 6 A C nyelvben a hívás során nem használhatjuk a formális paraméterek nevét. Programozás módszertan p.39/110
! R T K L 0 U UV T K = " # 0 U T K # 5 W Programozás módszertan p.40/110 Ada Az Ada nyelv esetében a paraméterek neve felhasználható a híváskor: 7 ' #" 9 $ $ " / > 1 3 U 2
Alprogramok törzse Programozás módszertan p.41/110
Alprogramok törzse Az alprogramok törzse tartalmazza az utasításokat, amelyeket az alprogram hívásakor végre kell hajtani és a változódeklarációkat, amelyek a lokális változókat írják le. Az alprogramok utasításai és a lokális változók deklaráció egyes programozási nyelvekben elkülönülnek (Pascal, Ada), más nyelvekben kevésbé (C), egyesekben pedig egyáltalán nem (Java, C++). Programozás módszertan p.42/110
Visszatérés A függvényből való visszatérés során meg kell adnunk a visszatérési értéket. A legtöbb nyelvben erre a return utasítás használható, amely után a visszatérési értéket adjuk meg. Egyes korai nyelvekben (FORTRAN, ALGOL 60, Pascal) a függvény neve kap értéket a return utasítás végrehajtása előtt. Programozás módszertan p.43/110
Alprogramok hívása Programozás módszertan p.44/110
Alprogramok hívása Alprogramok hívása az alprogram nevének megadásával és az aktuális paraméterek megadásával történik (néhány régebbi nyelv esetében szükséges a CALL utasítás használata). Az aktuális paraméterek listáját általában () jelek közt adjuk meg, amelyek üres lista esetén sem hagyhatók el. Programozás módszertan p.45/110
Alapértelmezett paraméterek Néhány nyelvben alapértelmezett értéket rendelhetünk a paraméterekhez. Az ilyen esetekben a függvény paramétereinek száma állandó, de nem feltétlenül mindet kell megadnunk a függvény hívásakor. Programozás módszertan p.46/110
Belépési pontok Néhány programozási nyelvben (PL/I, FORTRAN 77) az alprogramot nem csak az elején lehet kezdeni, ahhoz több belépési pont is rendelhető. Ilyen nyelvekben általában minden belépési ponthoz saját paraméterlista rendelhető. Programozás módszertan p.47/110
Belépési pontok (példa)! 1 78 :9 ;8 =<?> = > XY = Z< ' V 0 D 3 2 = K D 3 E ; < ; F G 4? > :< [ = > X ' V 3 5 = K F 6 V K V N = 7 F G? A> Programozás módszertan p.48/110
G 'S - 1 Objektumorientált módszer Objektumorientált nyelvek esetében az alprogramok (metódusok) az objektumokhoz tartoznak. Az objektumot a híváskor meg kell adnunk, azt is mondhatnánk, hogy az objektum az első paraméter. 1 3)4 A metóduson belül külön kulcsszóval (this, self, Current, me) hivatkozhatunk az objektumra, amelyre meghívtuk a metódust. Programozás módszertan p.49/110
Rekurzív alprogramok Programozás módszertan p.50/110
Rekurzív alprogramok Az alprogramokat, amelyek önmagukat hívják, közvetlenül rekurzív alprogramoknak nevezzük. Az olyan alprogramokat, amelyek más alprogramokon keresztül hívják önmagukat, közvetetten rekurzív alprogramoknak hívjuk. Programozás módszertan p.51/110
Rekurzív alprogramok A rekurzív alprogramok a programvégrehajtás adott időpontjában több példányban is aktív lehet. A lokális változókat minden aktív alprogrampéldány számára biztosítani kell, ezért az olyan nyelvekben, amelyek lehetővé teszik a rekurzív alprogramhívást, a lokális változók kezelése költséges lehet. Programozás módszertan p.52/110
Rekurzív alprogramok Bizonyos nyelvekben egyáltalán nem lehet rekurzív alprogramokat írni (pl. FORTRAN 77), másokban lehet (pl. C, C++), ismét másokban lehet, de külön jelölni kell, ha a függvényben rekurzív hívást akarunk használni (FORTRAN 90). Programozás módszertan p.53/110
Makrók és inline alprogramok Programozás módszertan p.54/110
A makró A makró igen egyszerű alprogramszerkezet, olyan szöveges érték, amelyet más szöveg helyére illesztünk be a program fordítása előtt. A makróérték a forrásprogramba helyettesítődik, így a programfutás során megtakaríthatjuk az alprogram hívását és a visszatérését. Sok esetben éppen a gyors hívás értékében használunk makrót. Programozás módszertan p.55/110
Makróparaméterek A makrók paraméterezhetők, de a formális paraméterek típusellenőrzés nélkül helyettesítődnek be az aktuális paraméterek értékére szöveges másolással. A makrók paramétereit óvatosan kell kezelnünk, a makrók törzsének átírásakor az összes makróhívást ellenőriznünk kell. Programozás módszertan p.56/110
! 3 3 P ' 3 ' 3 P ' 3 P ' ^ 3 ' ' @] L B \ T + 0 ` C A C programozási nyelvben a makrók az előfeldolgozó utasításai, a következő formában: 1 % Mi történik, ha a makrót paraméterrel hívjuk meg? Programozás módszertan p.57/110
Inline alprogram A makrókkal kapcsolatos problémák megoldására használhatók az inline alprogramok. Az inline alprogramok minden tekintetben megegyeznek az egyéb alprogramokkal, de a fordító nem a megszokott módon hívja őket, hanem behelyettesíti a hívások helyére az alprogram kódját. Programozás módszertan p.58/110
d b a c b a 3 P ' 5 0 I ^ P T + " " O C, C++ A C++ programozási nyelvben szabványos és a modern C fordítók által elfogadott kulcsszó jelzi, hogy a függvényt a hivatkozás helyére be kell helyettesíteni. 1 2 3 4 $ P 4 Programozás módszertan p.59/110
Paraméterátadás Programozás módszertan p.60/110
Paraméterátadás Az információáramlás irányának szempontjából a paramétereket három csoportra oszthatjuk: Bemenő paraméterek. Kimenő paraméterek. Be- és kimenő paraméterek. Programozás módszertan p.61/110
Paraméterátadási módok A paraméterátadás módszere alapján a következő csoportokat különböztethetjük meg: Érték szerinti paraméterátadás. Cím szerinti paraméterátadás. Eredmény szerinti paraméterátadás. Érték/eredmény szerinti paraméterátadás. Szövegszerű behelyettesítés. Név szerinti paraméterátadás. Programozás módszertan p.62/110
Érték szerinti paraméterátadás A bemenő paraméterek átadására használható módszer. A formális paraméter lokális változó, az aktuális paraméter értéke ide másolódik. Az alprogram megváltoztathatja a formális paraméter értékét, de ez nincs hatással az aktuális paraméter értékére. Ennek a módszernek a használatakor bármi lehet aktuális paraméter, aminek értéke van (pl. kifejezés). Programozás módszertan p.63/110
Érték szerinti paraméterátadás Mivel az aktuális paraméterek értéke egy adott pillanatban másolódik át a formális paraméterek területére, az aktuális paraméterek későbbi megváltozása nincs hatással a formális paraméterek értékére. (Az aktuális paraméter lehet egy globális változó, amelyet az alprogram megváltoztathat.) Programozás módszertan p.64/110
Pascal A Pascal nyelvben az érték szerinti paraméterátadás az alapértelmezett paraméterátadási mód. Programozás módszertan p.65/110
3 ' % # ( I 4 F N K O C A C programozási nyelvben kizárólag érték szerinti paraméterátadási mód létezik. A következő függvénynek nincs hatása, a megváltoztatott formális paraméter értéke a visszatéréskor megsemmisül: 1 2 3 4 #( Programozás módszertan p.66/110
3 6 ' % # ( I 4 F N 6 6 K O C Ha olyan függvényt akarunk készíteni, amely megváltoztatja a paraméterként kapott értéket, a paraméter címét adjuk át: 1 2 3 4 #( Programozás módszertan p.67/110
Cím szerinti paraméterátadás Cím szerinti paraméterátadást be- és kimenőparaméterek kezelésére használhatjuk. A cím szerinti paraméterátadás használatakor az alprogram egy hivatkozást kap az aktuális paraméterhez, így az alprogram és a hívó ugyanazt a memóriaterületet (ugyanazt a változót) érik el. A paraméternek olyan objektumnak kell lennie, amelyre hivatkozás (memóriacím) mutathat. Programozás módszertan p.68/110
`f e = " % + " $# " 4 F N + K Pascal A Pascal programozási nyelvben a kulcsszóval jelölhetjük, hogy az adott paramétert cím szerint szeretnénk átadni. 1 2 3 4 P 1 % 4 #( ')( 3)4 " 1 Programozás módszertan p.69/110
C A C programozási nyelv a tömböket cím szerinti paraméterátadással kezeli. A következő példa bemutatja hogyan fogadhatunk tömböket paraméterként: 1 ( # % #( '. 2 3 2 I 3. G 2 K. G 2 N F 4 4.F 2 K.F 2 N F 4 5 O Programozás módszertan p.70/110
Eredmény szerinti paraméterátadás Eredmény szerinti paraméterátadással kimenő paramétereket adhatunk át. A formális paraméter az alprogram lokális változója, amelynek az értékét az alprogram az aktuális paraméter helyére másolja az alprogram végrehajtása után. Ez a paraméterátadási mód meglehetősen ritka. Programozás módszertan p.71/110
Érték/eredmény paraméterátadás Az érték/eredmény szerinti paraméterátadást be- és kimenő paraméterek átadására használhatjuk. Az érték/eredmény paraméterátadás az alprogram hívásakor érték szerinti paraméterátadás használ (aktuális paraméterek értékének másolása a formális paraméterek területére), az alprogram befejeződésekor eredmény szerinti paraméterátadást (ua. fordítva) használ. Programozás módszertan p.72/110
3 = # ' " % $# " 4 F N @ + @ K % Ada Az Ada nyelvben a következő mintára használhatjuk az érték/eredmény szerinti paraméterátadást: 1 #( @ + " 1 2 P 1 3 4 4 #( Programozás módszertan p.73/110
Szövegszerű behelyettesítés A szövegszerű behelyettesítést makrók esetén használjuk, nem tekinthető valódi paraméterátadásnak. Szövegszerű behelyettesítés esetén a programszövegben a formális paramétereket jelző karakterláncokat lecseréljük az aktuális paramétereket jelző karakterláncokra. Programozás módszertan p.74/110
Többszörös kiértékelés (C) g 1 \ % L B @] ' 0 J 3 ' ' 3 T ' J 3 ^ ' 3 + ' J 3 3 2 3 4 K 5 ' N F 0 h h H 3)4 5 i j k 1 2 K ' ' N F 3 T ' h h H 3 ^ ' N F 3 + ' h h H 3 3)4 3 Programozás módszertan p.75/110
Zárójelezés (C) g 1 \ % L?> E l[? < ' 3 ' 6 3 2 3 4 K?> E l[? < ' P N F 3 5 i j k 1 2 K P N F 6 P N F 4 3 Programozás módszertan p.76/110
Név szerinti paraméterátadás A név szerinti paraméterátadás be- és kimenő paraméterek átadására használható. A név szerinti paraméterátadás kifejlesztésének célja az volt, hogy a makróassemblerekben használt szövegszerű behelyettesítésnél fejlettebb eszközzel dolgozhassunk. A név szerinti paraméterátadás a program, a paraméterek jellege szerint különböző adatátadási módszereket használ. Programozás módszertan p.77/110
Név szerinti paraméterátadás Ha az aktuális paraméter literál vagy konstans kifejezés, érték szerint adódik át. Ha az aktuális paraméter változó, cím szerint adódik át. Ha az aktuális paraméter változót is tartalmazó kifejezés, a kifejezés újra és újra kiértékelődik, ahányszor a formális paraméterre hivatkozunk az alprogramban (szövegszerű paraméterátadás). Programozás módszertan p.78/110
! % #/ " " 0 0 0 #/ ( 0 #/ 0 0 " " + # % = K + #" L #/ " + % Jensen s device (ALGOL 60) 3)4 1 ' 5 " $# " 4 1 4 " " 4 1 " 1 P 1 4 " G 4 K 1 4 " N " K 4 " K + 5 5 1 2 3 4 5 6 7 8 9 10 11 Az alapértelmezett paraméterátadási mód név szerinti. Programozás módszertan p.79/110
G F F S N 6 m 6 6 R ' 5 K + - h 0 0 0 Jensen s device (ALGOL 60) Számítsuk ki y = 10 x=1 3x 2 5x + 2 értékét a következő hívással: 1 3)4 A második paraméter cím szerint adódik át. A ciklusban megváltoztatjuk x értékét és ahányszor hivatkozunk az első paraméterre, kiszámítjuk a kifejezés értékét. Programozás módszertan p.80/110
Példák A következő néhány oldalon programozási nyelveket vizsgálunk meg a paraméterátadás szempontjából. Megvizsgáljuk, hogy milyen válaszokat adnak az egyes nyelvek a gyakorlatban felmerülő problémákra. Programozás módszertan p.81/110
FORTRAN A FORTRAN paraméterkezelése be- és kimenőparaméterek használatát teszi szükségessé, a szabványok azonban nem írják elő milyen paraméterátadási módot kell használnia a fordítónak. Régebbi FORTRAN megvalósítások általában cím szerinti paraméterátadást használnak, az újabbak érték/eredmény szerinti paraméterátadást. Programozás módszertan p.82/110
FORTRAN Ha az aktuális paraméter literál vagy összetett kifejezés, a fordító ideiglenes változót hoz létre, amelyet cím vagy érték/eredmény szerint ad át. A FORTRAN fordító általában nem tekinti hibának, ha az alprogram megváltoztatja az ilyen eredetű formális paramétert, a változás azonban elveszik az alprogram futásának végén. Programozás módszertan p.83/110
ALGOL 60 Az ALGOL 60 alapértelmezett paraméterátadási módja a név szerinti, választható azonban az érték szerinti paraméterátadási mód is. A név szerinti paraméterátadást nem sok nyelv vette át, meglehetősen ritka. Ennek oka nyilván a név szerinti paraméterátadás bonyolultsága és viszonylag alacsony gyakorlati haszna. Jellemzően érték szerinti és cím szerinti paraméterátadást használ az ALGOL 68. Programozás módszertan p.84/110
C A C programozási nyelvben igen jellemző az érték szerinti paraméterátadás, amely világossá, kezelhetővé teszi az alprogramokat. Az egyetlen dolog, amit a C tervezői az egyszerűség elé helyeztek, a hatékonyság, ezért a tömbök paraméterként való átadása esetén cím szerinti paraméterátadást használunk. A C++ a referencia bevezetésével egyszerűsítette a mutatók átadását, alapvetően azonban nem változtatott a paraméterátadáson. Programozás módszertan p.85/110
n d f q op C# A C# paraméterátadása meglehetősen bonyolult. Alapértelmezett esetben bizonyos típusok hivatkozás (cím) szerint, bizonyos típusok pedig érték szerint adódnak át. A kulcsszóval elérhetjük, hogy az alprogram megváltoztathassa az aktuális paramétereket. Az kulcsszóval kényszeríthető a kimenő paraméterként való használat, melynek során a paraméter nem tekinthető inicializáltnak az alprogram elején és kötelezően inicializálandó az alprogramban. Programozás módszertan p.86/110
a q op b a b q op Ada Az Ada paraméterátadása esetén a programozó nem a paraméterátadás módját, hanem az irányát határozhatja meg az, kulcsszavakkal. Az alprogram az paramétereket nem változtathatja meg, az paramétereket nem olvashatja ki. Programozás módszertan p.87/110
Alprogramok környezete Programozás módszertan p.88/110
Külön fordíthatóság Csak azok a programozási nyelvek (és fordítóprogramok) alkalmasak nagy méretű programok készítésére, amelyek alkalmasak arra, hogy a fordítást részenként, fordítási egységenként végezzük el. Ha fordítási egységenként végezzük el a fordítást, a fordítóprogramnak csak az adott fordítási egység objektumait kell kezelnie, a fordítás kevesebb erőforrást igényel. Ha a fordítási egységenként végezzük el a fordítást, csak azokat az egységeket kell újrafordítani, amelyben módosítottunk. Ez drasztikusan csökkenti a fordítási időt. Programozás módszertan p.89/110
Külön fordítási egység Az alprogramok természetes határt jelölnek, kézenfekvőnek tűnik, hogy az alprogramok alkossanak fordítási egységet, azaz a program legyen fordítható alprogramonként. Igaz azonban az is, hogy sok programozási nyelv esetében nem alprogramonként történik a fordítás. Programozás módszertan p.90/110
ASA FORTRAN Az ASA FORTRAN esetében az alprogramok fordítási egységek, azaz a program fordítható alprogramonként. (Emlékezzünk a FORTRAN tanulmányainkra: a változók, címkék, függvények deklarációi az alprogramon belül érvényesek, így az alprogram a program többi része nélkül fordítható.) Programozás módszertan p.91/110
df q dr b x v u ts 4 C A C programozási nyelvben a fordítási egység az állomány, amelyben egy vagy több alprogram (függvény) lehet, az alprogram tehát a legkisebb fordítási egység. A C nyelvben az adott fordítási egység által használt származtatott típusokat és a függvények típusait ha azokat más fordítási egységben is használjuk header állományokból töltjük be. A C nyelvben a fordítási egységen kívüli globális változót az kulcsszóval kell deklarálni: w 1 " Programozás módszertan p.92/110
Egyéb nyelvek Az Ada nyelvben az alprogram lehet fordítási egység, a Modula-2, Java és Clean nyelvekben a fordítási egység összetettebb az alprogramnál. A FORTRAN II és a Pascal korai változatai csak egész programokat képesek fordítani. Bizonyos nyelvek esetében (pl. PL/I, C) a fordító nem képes az alprogramok deklarációit ellenőrizni, ha azok nem az aktuális fordítási egységben vannak. A PL/I és a C lehetővé teszi külső alprogram típusának deklarációját. Programozás módszertan p.93/110
Beágyazhatóság Bizonyos nyelvek lehetőséget adnak arra, hogy az alprogramokat (esetleg utasításblokkokat) egymásban ágyazzuk, azaz alprogramokon belül alprogramokat, utasításblokkon belül utasításblokkokat hozzunk létre. Programozás módszertan p.94/110
zy C A C programozási nyelv esetében a jelek segítségével utasításblokkot hozhatunk létre. Az utasításblokkok egymásba ágyazhatók. A C programozási nyelv nem teszi lehetővé alprogramok (függvények) egymásba ágyazását. A GNU C fordító tartalmaz ilyen bővítést (azaz kezeli a függvényeken belüli függvényeket), de ezt a lehetőséget humanoid programozók nem használják. Programozás módszertan p.95/110
Java A Java nyelvben osztályokat egymásba ágyazhatunk (az osztályokban természetesen lehetnek metódusok), osztályokat alprogramba ágyazhatunk, de alprogramokat nem ágyazhatunk alprogramokba. (Ha az osztályokat típusoknak tekintjük, a koncepció érthetővé válik.) Programozás módszertan p.96/110
Modula-2, Ada A Modula-2 és az Ada nyelvekben az alprogramokat alprogramba ágyazhatjuk, így a hatókör csökkenthető, az alprogram elrejthető, a bonyolultság csökkenthető. (Az alprogram és általában az információ elrejtésének elve azt mondja ki, hogy a program megértéséhez nem feltétlen szükséges elemeket rejtsük el, azok ne zavarják a programozót.) Programozás módszertan p.97/110
Statikus és dinamikus hatókör Statikus hatókörről beszélünk, ha a hatókör kizárólag a programegységek egymásba ágyazása alapján eldönthető. A statikus hatókört használó nyelvek esetén csak azokban a programsorokban érvényes az objektum, amelyek a hatókörét meghatározó programegységen belül találhatók. Dinamikus hatókör esetén a hatókört befolyásolja a hívási lánc, az objektum hatóköre kiterjed a hívott alprogramokra is. Programozás módszertan p.98/110
Statikus típusosság és hatókör A statikus típusosság megköveteli a statikus hatókört, mert dinamikus hatókör esetén csak a futáskor dönthető el, hogy két azonos nevű, de különböző típusú változó közül melyiknek érvényes a hatóköre az adott esetben. Nyilvánvaló, hogy a statikus hatókört használó nyelveken megírt programot sokkal könnyebb elolvasni, megérteni. Különösen igaz ez mély hívási lánc esetén a távol deklarált objektumok esetében. Programozás módszertan p.99/110
Élettartam Láttuk, hogy az alprogramok lokális változói és formális paraméterei általában dinamikus tárolási osztályúak, ami azt jelenti, hogy élettartamuk az alprogram aktív idejére korlátozódik. Addig léteznek, amíg az alprogram aktív. Léteznek statikus tárolási osztályt használó nyelvek is és olyanok is, ahol a programozó írhat elő statikus tárolási osztályt. Programozás módszertan p.100/110
Alprogramnevek túlterhelése Léteznek olyan nyelvek, ahol azonos néven több alprogramot is létrehozhatunk. Ezeknek a nyelveknek az esetében a fordító a híváskor eldönti, hogy melyik alprogramot kívánjuk hívni az adott ponton. A fordító a döntéshez az alprogram specifikációját használhatja, azaz a híváskor a specifikációban található információk alapján egyértelműen eldönthetőnek kell lennie, hogy melyik függvényt kell hívni. Ez természetesen azt jelenti, hogy a túlterhelés során a név megegyezik ugyan, de a specifikáció nem lehet azonos. Programozás módszertan p.101/110
Ada Az Ada programozási nyelvben a szokásos túlterhelés mellett az alprogramokat hívhatjuk minősített névvel. A minősítés a csomag nevéből áll. Ez a lehetőség hasznos, ha különböző csomagokban azonos nevű és specifikációjú alprogram van. Programozás módszertan p.102/110
Java, C++ A Java és C++ nyelvekben a függvények visszatérési értékét nem kötelező felhasználnunk, ezért két azonos nevű alprogram közt nem tehetünk különbséget a visszatérési értékkel. Következik ebből, hogy ezekben a nyelvekben nem készíthetünk azonos nevű függvényeket, amelyek csak a visszatérési érték típusában különböznek. Programozás módszertan p.103/110
Operátorok túlterhelése Az operátorok különleges alprogramok, amelyek különleges nyelvtan alapján hívhatók. Bizonyos nyelvek megengedik az operátorok túlterhelését, azaz lehetővé teszik, hogy a programozó megadja vagy megváltoztassa az operátorokat megvalósító alprogramokat adott típusra. A legtöbb programozási nyelvben, amelyben a beépített operátorok túlterhelhetők, új operátor nem hozható létre. Programozás módszertan p.104/110
C++ A C nyelvvel szemben a C++ lehetővé teszi, hogy a beépített operátorokat túlterheljük. Az objektumorientált módszertan és az operátorok túlterhelése jól együttműködő párosa igen nagy kifejezőerőt kölcsönöz a nyelvnek. A C++ nyelvvel szemben a Java nem teszi lehetővé az operátorok túlterhelését. Programozás módszertan p.105/110
Ada Az Ada operátorai túlterhelhetők, de újabb operátort nem lehet létrehozni. A túlterhelt operátor örökli a beépített operátor precedenciáját, ami ésszerű határt szab a programozó dühöngő kreativitásának (a precedenciát a legtöbb programozó percepcionális szinten tanulta meg). Programozás módszertan p.106/110
Alprogramok megvalósítása Programozás módszertan p.107/110
A végrehajtási verem Az program végrehajtása során az egyes alprogramok egymást hívják, azaz indítják el, egy időben tehát több alprogram is lehet aktív. Rekurzív hívás esetén ugyanaz az alprogram több példányban is aktív lehet. Az alprogramok hívási szerkezete a veremre emlékeztet: az az alprogram fejeződik be előbb, amely később indult. Ezért a programok az alprogramok kezelését veremmel (runtime stack) kezelik. Programozás módszertan p.108/110
Hívási lánc Amikor egy alprogramot hívunk adatok kerülnek a verembe, amikor pedig befejezzük az alprogram végrehajtását, az adatokat eltávolítjuk a veremből. A veremből mindig kideríthető, hogy melyek az aktív alprogramok, hogy melyik alprogram hívta a másikat. Az egymást hívó alprogramok sorozatát hívási láncnak, a veremben az alprogramról tárolt adatokat aktivációs rekordnak nevezzük. Programozás módszertan p.109/110
Aktivációs rekord Az aktivációs rekord tartalmazza: A memóriacímet, ahová vissza kell térni az alprogram befejezésekor. A regiszterek híváskori értékét. A legtöbb programozási nyelv esetében a lokális változók és a paraméterek értékét. Rekurzív függvényhívás esetében minden futó példány saját aktivációs rekorddal (és így saját lokális változókészlettel) rendelkezik. Programozás módszertan p.110/110