110

Programozás módszertan )

Pere László (

Alprogramok

P ÉCSI E GYETEM T ERMÉSZETTUDOMÁNYI K AR I NFORMATIKA ÉS Á LTALÁNOS T ECHNIKA TANSZÉK M AGYAR T UDOMÁNYOS A KADÉMIA S ZÁMÍTÁSTECHNIKAI ÉS AUTOMATIZÁLÁI K UTATÓINTÉZET E L EARNING O SZTÁLY

Programozás módszertan – p.1/110

Bevezetés


Bevezetés Az alprogramok több szempontból is javítják a szoftvermin˝oséget: Újrafelhasználhatóság. Olvashatóság. Módosíthatóság. Karbantarthatóság.


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


Kapcsolattartás


Kapcsolattartás Az alprogramok a számításokat a paraméterként átvett értékeken (bemen˝o 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˝o paraméterek értékének megváltoztatásával adhatnak vissza értéket (formális és aktuális paraméterek egymáshoz rendelése).


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


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


a) Tömbök


Meghatározatlan méretu˝ 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˝o, amely többféle konkrét típussal is használható. E lehet˝oség tipikus használata a meghatározatlan méret˝u tömböt kezel˝o alprogram készítése.


Pascal !

"

1

4 3 )

+

2 "

1

+

0

/#

1

. -

"

"

"

,+*

&

( ' )

%

"

"

#$ "

1

%

A Standard Pascalban meghatározatlan méret˝u tömböt a következ˝o formában adhatunk át: Az alprogramon belül a low és high változók hordozzák a tömb fels˝o és alsó indehatárát.


Ada Adában a paraméterként átvett tömb fels˝o é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˝o indexérték pedig V’Last.


C

4 3 )

"

5

0

6

5

5

5

'

0

4)3

"

5

2

.

5

5

5

2

1

'

A C programozási nyelvben átadhatjuk a tömböket az els˝o 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˝u 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˝u tömb).


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˝o a tömbb˝ol.


FORTRAN

3 B

D?

?

C 0 G

G

'F B

D

@

3

C

B

:

?E

0

B

B'

A@ >?

<=

9:
>

= ?

3

:

2

87

1

8;

A FORTRAN 77 lehet˝ové teszi meghatározatlan méret˝u tömbök átadását. A méretet külön változóban adjuk át.

A FORTRAN 77 meghatározatlan méret˝u tömbjei kizárólag paraméterátadásra használhatók, végso˝ soron minden meghatározatlan méret˝u tömb valamely meghatározott méret˝u tömb hordozására használható.


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˝o index határait, nem tudjuk kiszámítani a második sor címét.


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.


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.


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.


C/C++

#

"#

0

H 4)3

2 G

G

F.

2

.

5

5

5

1

'

A C és C++ nyelvekben nehézkes a többdimenziós tömbök meghatározatlan méret˝u tömbként való átadása. A programozó el˝ott két út áll: vagy megvalósítja a címfüggvényt, vagy csak az oszlopok méretét hagyja definiálatlanul:


8 4

K

N

#

$

6

N

J

"

5

6

N

3

'

K

J

L

4

N

N

#

$

M

J

J

4 G

"#

3

'

5

6

K

4

/#

"

N

N

M

4 G

L

3

'

4 "#

0

0

K

J

4 G

3

"

7

I

2

"

0

0

6 "

5

5

!

#

3

'

$

/#

"

1

O

C/C++


a) Alprogramok


Alprogramok Sokszor hasznos lehet alprogramoknak paraméterként alprogramot átadni. Jellemz˝o példa lehet a tetsz˝oleges függvényt integráló vagy deriváló alprogram vagy az elemeket sorbarendezo˝ általános rendez˝o alprogram (amely a rendezend˝o tömbön kívül megkapja az elemek összehasonlítására használható függvényt paraméterként).


Alprogramok Korai programozási nyelvek nem tették lehet˝ové 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˝osé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˝o változóban.


9 K

45

"

1

K

4

6

3

- P

1

/#

L '

K

+

L

#

5

5

"#

N

+

7

+

8

6

K

5

G 4 G

+

1

0

4

"

"

+5

(

0

0

"

4

"

+ 3

+

1

/#

2

4 %

5

4 P

3

L

"

L

L

'

4

!

"

+ 3

"

'

#

$

1

+

$

#

1

Pascal


10 45

K

4

N K

5

4

6

N

/#

3

'

L

6

/#

7

K

M

I

3

'

1

/#

K

5

P

%

G 4 G

#

4

8 O

I

0

P

%

# P

%

1

#

3

2

"

9

5 /

3

"

0

0

P

%

"

#

#

#

6

P

%

P

%

P

%

1

L

/#

#

3

'

3

'

'

1

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˝o címét (a függvény címét) kapjuk.


c) Címke


Címke Bizonyos nyelvekben (ALGOL 60, PL/I, SIMULA 67, ALGOL 68) címkéket is átadhatunk paraméterként. Ez a lehet˝oség kit˝un˝oen 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.


Alprogramok pecifikációja


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˝orizheti és lefordíthatja az alprogram hívását, így az alprogram törzse egy másik fordítási egységben is lehet.


Paraméterek száma Néhány programozási nyelv nem ellen˝orzi a paraméterek számát (általában a script nyelvek). Ezen nyelvek esetében tetsz˝oleges számú paraméterrel hívhatjuk az alprogramokat. A legtöbb programozási nyelv ellen˝orzi a paraméterek számát, néhányukban többféle paraméterszámmal is hívhatjuk az alprogramokat.


C

4 3 )

L

0

5

"#

"

6

$

#

L $ '

"

1

A C programozási nyelvben a . . . (ellipsis) kifejezéssel jelezhetjük, ha tetsz˝oleges számú paraméterrel szeretnénk hívni az alprogramot (variadic functions). A paraméterekhez ilyen esetben a va_list, va_start, va_arg, stb. makrókkal férhetünk hozzá.


C++

$

"

-

6 4)3

$

=

% 4 3 )

"

6 4 3 )

1

C

#

$ ' ( ' )

"

-

"

-

$ '

+

P

"

-

-

5

4

Q

3

2

$

1

I

C++ nyelvben azonos néven, különböz˝o 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:


C++

D

D 0 K

&

RS

G 4 3 )

0

K

5

6 5

-

>8

"

$

#

$

"

6

$

#

/

$ '

L

2

1

Arra is lehet˝oséget ad a C++, hogy egyes paramétereket elhagyjunk a függvény hívásakor (default érték):

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.


Paraméterek típusa Bizonyos nyelvek esetében a fordító nem ellen˝orzi azt, hogy a megfelel˝o típusú paraméterekkel hívtuk-e az alprogramot (pl. FORTRAN 77). A legtöbb modern nyelv ellen˝orzi a formális paraméterek és az aktuális paraméterek típusát (FORTRAN 90, Ada, Pascal, Java).


C

3 P

0

4 P

0

"

O

I

4 5

2 3

$

1

'

A C nyelv eredeti (K&R) változataiban a fordító a paraméterek típusának ellen˝orzését nem végezte el. Ezt a változatot használva a függvény szerkezete:


C

3 P

0

"

O

4

$

3

2

I

1

'

A C kés˝obbi (ANSI) változataiban már ellen˝orzi a fordító a paraméterek számát és típusát. Az elo˝ z˝o példa modern változata:

Ma már mindenki ezt a formát használja, de régi programokban még megtalálható a K&R változat is.


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


C

$

6 "

4 3 )

"

$

0

#

$

6 %

"

-

" $

6

"

$

1

$ '

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: A C nyelvben a hívás során nem használhatjuk a formális paraméterek nevét.


Ada !

R T

0

K W

K

/

5

#

T

U

U

3

0

K

"#

$

# "

"

T

9

L

U

VU

7 =

>

2

1

'

$

Az Ada nyelv esetében a paraméterek neve felhasználható a híváskor:


Alprogramok törzse


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


Visszatérés A függvényb˝ol 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˝ott.


Alprogramok hívása


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.


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.


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˝o. Ilyen nyelvekben általában minden belépési ponthoz saját paraméterlista rendelhet˝o.


K

N =

K F

4 D

0

<=

8;

9:

3

D 3

V'

!

=

YX

>

=

K

87

V'

G

F

;

=

>?

<

;

E

X

>

=

[

<:

>

?

3

V

5 =

1

>A

V

6

G

2

?

7 F

Belépési pontok (példa)


Objektumorientált módszer

G 4)3

1 -

1

S'

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˝o paraméter. A metóduson belül külön kulcsszóval (this, self, Current, me) hivatkozhatunk az objektumra, amelyre meghívtuk a metódust.


Rekurzív alprogramok


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.


Rekurzív alprogramok A rekurzív alprogramok a programvégrehajtás adott id˝opontjá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˝ové teszik a rekurzív alprogramhívást, a lokális változók kezelése költséges lehet.


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


Makrók és inline alprogramok


A makró A makró igen egyszer˝u alprogramszerkezet, olyan szöveges érték, amelyet más szöveg helyére illesztünk be a program fordítása el˝ott. A makróérték a forrásprogramba helyettesíto˝ 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.


Makróparaméterek A makrók paraméterezhet˝ok, de a formális paraméterek típusellen˝orzés nélkül helyettesít˝odnek 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˝oriznünk kell.


C

!

3

3

'

3

'

P

P

_

_

Mi történik, ha a makrót

`

0

+

T

P

^

3

'

3

'

'

3 ]@ B

L

\

%

1

'

A C programozási nyelvben a makrók az el˝ofeldolgozó utasításai, a következ˝o formában:

paraméterrel hívjuk meg?


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 o˝ ket, hanem behelyettesíti a hívások helyére az alprogram kódját.


C, C++ a

b

3 P

0

5

$

+

4 P

^ P T

" O

4

3

"

2

I

1

'

b

d

c

a

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.


Paraméterátadás


Paraméterátadás Az információáramlás irányának szempontjából a paramétereket három csoportra oszthatjuk: Bemen˝o paraméterek. Kimen˝o paraméterek. Be- és kimen˝o paraméterek.


Paraméterátadási módok A paraméterátadás módszere alapján a következo˝ 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˝u behelyettesítés. Név szerinti paraméterátadás.


Érték szerinti paraméterátadás A bemen˝o 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).


É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˝obbi 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.)


Pascal A Pascal nyelvben az érték szerinti paraméterátadás az alapértelmezett paraméterátadási mód.


C

3

(#

F N K

4

O

4

% # (

3

2

I

1

'

A C programozási nyelvben kizárólag érték szerinti paraméterátadási mód létezik. A következ˝o függvénynek nincs hatása, a megváltoztatott formális paraméter értéke a visszatéréskor megsemmisül:


C

3

6

(#

F N K

4

6 O

4

% # (

3

6

2

I

1

'

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:


Cím szerinti paraméterátadás Cím szerinti paraméterátadást be- és kimeno˝ 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.


Pascal

4 3 )

"

1

=

+

"

( ' )

(#

"

N K

4

+ 4 %

4

F

3

P

2

1

"

#$

%

1

e

f`

A Pascal programozási nyelvben a kulcsszóval jelölhetjük, hogy az adott paramétert cím szerint szeretnénk átadni.


C

3

2

.

(#

F

2

.

F

2 O

K

4

N

F.

F.

K

4

N

G

2 G

.

4 5

% # (

3

2

2

I

1

'

A C programozási nyelv a tömböket cím szerinti paraméterátadással kezeli. A következ˝o példa bemutatja hogyan fogadhatunk tömböket paraméterként:


Eredmény szerinti paraméterátadás Eredmény szerinti paraméterátadással kimeno˝ 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˝osen ritka.


Érték/eredmény paraméterátadás Az érték/eredmény szerinti paraméterátadást be- és kimen˝o 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˝odésekor eredmény szerinti paraméterátadást (ua. fordítva) használ.


Ada

"

1

= #

+ @

(#

"

F 4

N

@ 4

(#

K

+ %

4

@

3

1

P

2

"

#$

%

'

1

3

Az Ada nyelvben a következ˝o mintára használhatjuk az érték/eredmény szerinti paraméterátadást:


Szövegszeru˝ behelyettesítés A szövegszer˝u behelyettesítést makrók esetén használjuk, nem tekinthet˝o valódi paraméterátadásnak. Szövegszer˝u behelyettesítés esetén a programszövegben a formális paramétereket jelz˝o karakterláncokat lecseréljük az aktuális paramétereket jelzo˝ karakterláncokra.


3

h

h

h

h

K

H

^

3

'

3

N

H

F

3

'

3

4 3 )

+

T

F

'

N

'

'

2

1

j

i

k

5

0

h

h

K

F

H 4 3 )

N

+

T

J

^

J

J

]@

'

0

L B

2

5

4

3 \

3

3

'

3

'

3

'

3

'

'

3

'

1 %

g

Többszörös kiértékelés (C)


3

K

4

6

N

N

P

P

F

F

2

1

j

i

k

5

K

N

P

<

?

[l

>?

F

E

3

'

4

3 \

6

<

?

[l

>?

L

E

3

'

3

'

1 %

g

Zárójelezés (C)

2


Név szerinti paraméterátadás A név szerinti paraméterátadás be- és kimeno˝ 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˝u 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˝o adatátadási módszereket használ.


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ékelo˝ dik, ahányszor a formális paraméterre hivatkozunk az alprogramban (szövegszer˝u paraméterátadás).


K

4

" K

4

+

"

N

"

K

=

#

%

1

/#

+

K 4 G

+

4

"

1

0

0

4

1

/#

"

1

4

L

8 "#

6 "

4

"

"

3

5

5

9 "

7 "

0

4

1

/#

(

2

+

10

P

5

%

11

0

0

0

"

5

%

4)3

1

'

#$

/#

"

"

"

1

!

Jensen’s device (ALGOL 60)

Az alapértelmezett paraméterátadási mód név szerinti. Programozás módszertan – p.79/110

Jensen’s device (ALGOL 60) Számítsuk ki y=

10 X

2

3x − 5x + 2

x=1

G 4)3

F

F

S 6

6

6

N

m

R

5

0

0

0

h

K

+

-

1

'

értékét a következ˝o hívással: 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˝o paraméterre, kiszámítjuk a kifejezés értékét.


Példák A következ˝o 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˝o problémákra.


FORTRAN A FORTRAN paraméterkezelése be- és kimen˝oparaméterek használatát teszi szükségessé, a szabványok azonban nem írják el˝o 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.


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˝u formális paramétert, a változás azonban elveszik az alprogram futásának végén.


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˝osen ritka. Ennek oka nyilván a név szerinti paraméterátadás bonyolultsága és viszonylag alacsony gyakorlati haszna. Jellemz˝oen érték szerinti és cím szerinti paraméterátadást használ az ALGOL 68.


C A C programozási nyelvben igen jellemz˝o az érték szerinti paraméterátadás, amely világossá, kezelheto˝ vé teszi az alprogramokat. Az egyetlen dolog, amit a C tervez˝oi az egyszer˝usé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˝usítette a mutatók átadását, alapvet˝oen azonban nem változtatott a paraméterátadáson.


C#

po

q

f

d

n

A C# paraméterátadása meglehet˝osen 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˝o a kimen˝o paraméterként való használat, melynek során a paraméter nem tekinthet˝o inicializáltnak az alprogram elején és kötelez˝oen inicializálandó az alprogramban.


Ada

po

q

b

a

po

b

q

a

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. paramétereket nem változtathatja Az alprogram az meg, az paramétereket nem olvashatja ki.


Alprogramok környezete


Külön fordíthatóság Csak azok a programozási nyelvek (és fordítóprogramok) alkalmasak nagy méret˝u 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 ero˝ 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˝ot.


Külön fordítási egység Az alprogramok természetes határt jelölnek, kézenfekv˝onek t˝unik, 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.


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


C

x

w

v

4

"

1

st

u

b

fd

rd

q

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:


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˝orizni, ha azok nem az aktuális fordítási egységben vannak. A PL/I és a C lehet˝ové teszi küls˝o alprogram típusának deklarációját.


Beágyazhatóság Bizonyos nyelvek lehet˝osé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.


C yz

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˝ové alprogramok (függvények) egymásba ágyazását. A GNU C fordító tartalmaz ilyen b˝ovítést (azaz kezeli a függvényeken belüli függvényeket), de ezt a lehet˝oséget humanoid programozók nem használják.


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˝ové válik.)


Modula-2, Ada A Modula-2 és az Ada nyelvekben az alprogramokat alprogramba ágyazhatjuk, így a hatókör csökkenthet˝o, az alprogram elrejthet˝o, a bonyolultság csökkenthet˝o. (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.)


Statikus és dinamikus hatókör Statikus hatókörr˝ol beszélünk, ha a hatókör kizárólag a programegységek egymásba ágyazása alapján eldönthet˝o. 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.


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öntheto˝ el, hogy két azonos nev˝u, de különböz˝o 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.


É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˝o statikus tárolási osztályt.


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˝uen eldönthet˝onek 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.


Ada Az Ada programozási nyelvben a szokásos túlterhelés mellett az alprogramokat hívhatjuk min˝osített névvel. A min˝osítés a csomag nevéb˝ol áll. Ez a lehet˝oség hasznos, ha különböz˝o csomagokban azonos nev˝u és specifikációjú alprogram van.


Java, C++ A Java és C++ nyelvekben a függvények visszatérési értékét nem kötelez˝o felhasználnunk, ezért két azonos nev˝u alprogram közt nem tehetünk különbséget a visszatérési értékkel. Következik ebb˝ol, hogy ezekben a nyelvekben nem készíthetünk azonos nev˝u függvényeket, amelyek csak a visszatérési érték típusában különböznek.


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˝ové 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˝ok, új operátor nem hozható létre.


C++ A C nyelvvel szemben a C++ lehet˝ové 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˝uköd˝o párosa igen nagy kifejez˝oer˝ot kölcsönöz a nyelvnek. A C++ nyelvvel szemben a Java nem teszi lehet˝ové az operátorok túlterhelését.


Ada Az Ada operátorai túlterhelhet˝ok, 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˝u határt szab a programozó dühöng˝o kreativitásának (a precedenciát a legtöbb programozó percepcionális szinten tanulta meg).


Alprogramok megvalósítása


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˝oben 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˝odik be el˝obb, amely kés˝obb indult. Ezért a programok az alprogramok kezelését veremmel (runtime stack) kezelik.


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 verembo˝ l. A veremb˝ol mindig kideríthet˝o, 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.


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.


110

Recommend Documents