Kihagyás

Függvények

Eljárásvezérlés

Elképzelhető, hogy egy műveletsort többször szeretnénk végrehajtani, esetlegesen a műveletsor bár többször ismétlődik, végrehajtása függ bizonyos paraméterektől. Eljárásvezérlésről akkor beszélünk, amikor egy műveletet adott argumentumokra alkalmazunk, aminek hatására az argumentumok értékei pontosan meghatározott módon változnak meg.

Az eljárásvezérlésnek két fajtája van: az eljárásművelet és a függvényművelet. Ez a két művelet bizonyos programozási nyelvek esetén teljesen meg vannak különböztetve, bizonyos nyelvek esetén szinte nincs különbség a kettő között. C nyelv esetében minimális a különbség a kettő között. Egyelőre csak a függvényművelettel foglalkozunk.

Függvényművelet

A C-ben használt függvényeket tekinthetjük a matematikai függvények általánosításának. Ha egy részprobléma célja egy érték kiszámítása adott értékek függvényében, akkor a megoldást megfogalmazhatjuk függvényművelettel.

A függvényművelet specifikációja tartalmazza

  • a művelet elnevezését,
  • a paraméterek felsorolását,
  • a paraméterek típusát,
  • a műveletek hatásának leírását,
  • a függvényművelet eredménytípusát.

A függvényművelet jelöléséra a T F(T1 X1, . . . , Tn Xn)` formát használjuk, ahol

  • T a függvényművelet eredménytípusa,
  • F a függvényművelet neve,
  • T<sub>i</sub> az i. paraméter típusa,
  • X<sub>i</sub> az i. paraméter azonosítója.

A zárójeleket akkor is ki kell tenni, ha a paraméter lista üres.

A C jelölésmódhoz alkalmazkodva a függvény algoritmusa egy olyan szerkezeti ábrával adható meg, amelynek a feje így néz ki:

kep

Azaz egy téglalap, amelynek függőleges oldalai meg vannak duplázva, és amely tartalmazza a függvényműveletet leíró legfontosabb adatokat.

A függvény megvalósítását leíró szerkezeti ábra alakja pedig a következő:

kep

Vagyis csak kiegészítjük a függvény deklarációját azzal a műveletsorral, amelyet a függvény által végrehajtunk.

Mivel a függvénynek van visszatérési értéke, így az M részműveletben lennie kell (legalább) egy olyan return utasításnak, amely visszaadja a függvény által kiszámított értéket.

A függvényművelet leírásában használt paramétereket szokás formális paramétereknek hívni, míg azokat az argumentumokat, amelyekre konkrét esetben végre szeretnénk hajtani a függvényt, aktuális argumentumoknak nevezzük. Ha a fenti függvényt végre szeretnénk hajtani az A1, ..., An aktuális argumentumokkal, akkor azt az F(A1, ..., An)` függvényhívással tehetjük meg. A függvényhívás kifejezés (ld. "Numerikus tényező szintaktikai leírása").

Amennyiben a függvény nem vár paramétereket, a zárójeleket akkor is ki kell tenni a szintaxisnak megfelelően:

Függvény deklaráció
kep
Függvény definíció
kep
Függvény fejléc
kep
Függvényhívás
kep
Return utasítás
kep

A szintaxis alapján a fenti szerkezeti ábrával megadott függvényt a

1
2
3
4
T F(T1 X1, ... , Tn Xn)
{
   M;
}

kóddal adhatjuk meg, meghívni pedig az F(a1, ..., an) módon lehet, ahol a1, ..., an kifejezések rendre T1, ..., Tn típusúak.

Egyszerű példa függvényre

Legyen a következő függvényünk:

1
2
3
4
double atlag (double a, double b)
{
    return (a+b)/2;
}

Ez az atlag függvény valóban úgy viselkedik, mint egy matematikai függvény. A paraméterben kapott két szám átlagát kiszámítja, majd visszatér a kiszámított értékkel. Mind a paraméterek, mind a paraméterek típusa valós, a függvény neve pedig jól tükrözi a függvény által megvalósított feladatot.

Példa: eltelt idő kiszámítása függvénnyel

A szekvenciális vezérlésnél ismertetett eltelt idő probléma algoritmusát módosítsuk annyival, hogy magát az eltelt időt egy függvény által határozzuk meg. Mivel a specifikáció részletei megegyeznek a korábbival, így ezeket most nem ismételjük, csak a változásra koncentráljunk.

Az algoritmus tervezés során az eltelt perceket kiszámító függvényt kell megadjuk. Ezt megtehetjük persze egy szöveges leírás által is, de megadhatjuk egy szerkezeti ábrával is. Ehhez először adjuk meg az eltelt_percek függvény leírását:

kep

majd a program fő részét, amelyben meghívjuk az előbb definiált függvényt:

kep

Tip

Ebben a formában a probléma megoldása nyilván nem optimális, hiszen kétszer hívjuk meg ugyanazokkal az argumentumokkal a függvényt. Hatékonyabb lenne, ha a függvényhívás eredményét eltárolnánk és újrafelhasználnánk, mindazonáltal most pont azért csináljuk így, hogy látszódjék, hogy a számítást újra és újra el tudjuk végezni. Adott esetben más (újabb) argumentumokkal is működne a számítás.)

Nézzük, miként változik a forráskód:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
/* Egy nap két időpontja között mennyi idő telt el.
 * 2007. Augusztus 30.  Gergely Tamás, gertom@inf.u-szeged.hu
 */

#include <stdio.h>

int eltelt_percek(int ora1, int perc1, int ora2, int perc2) {
    return 60 * ora2 + perc2 - (60 * ora1 + perc1);
}

int main() {
    int o1, p1;                         /* az első időpont */
    int o2, p2;                       /* a második időpont */
    int o, p;                             /* az eltelt idő */
    /* beolvasás */
    printf("Kérem az első időpontot óra perc formában\n");
    scanf("%d %d", &o1, &p1);
    printf("Kérem a második időpontot óra perc formában\n");
    scanf("%d %d", &o2, &p2);
    /* számítás */
    o = eltelt_percek(o1, p1, o2, p2) / 60;
    p = eltelt_percek(o1, p1, o2, p2) % 60;
    /* kiíratás */
    printf("Az eltelt idő: %d óra %d perc.\n", o, p);
    return 0;
}

Utolsó frissítés: 2020-10-13 06:15:04