Függvények

A függvény meghatározása

A legfontosabb technológiai áttörés a számítógépekben az olyan különálló kódrészek létrehozásának és a raktározásának a lehetősége, amelyek leírják az adatfeldolgozás szabályait vagy megoldanak egy problémát vagy annak egy kis részét. Ez a lehetőség az MQL4-ben szintén létezik.

A függvény a neve annak a speciális programrésznek, ami leírja az adatátalakítás módszerét.

Miközben függvényről beszélünk, két összetevővel fogunk találkozni:a  függvényleírással és a függvényhívással.

Függvényleírásnak egy program speciális végrehajtható részét nevezzük.

Függvényhívás (függvényreferencia) egy olyan rekord, aminek a végrehajtása egy függvény végrehajtásával végződik.

Mindennapos életünkben a függvénynek sok analógiáját találhatjuk. Vegyük például egy autó fékrendszerét. Az egész szerkezetnek, -ami a mérnök ötleteként megvalósítja a fékezést - egy függvény az analógiája, míg a fékpedál a függvényhívás analógiája. A vezető lenyomja a pedált, és a működésbe hozott szerkezetek végrehajtanak néhány műveletet és leállítják az autót.

Ugyanígy, ha egy függvényhívás történik egy programban, a hívott függvény végre fogják hajtani, vagyis egy számítást vagy egyéb műveletet fognak végrehajtani (például egy üzenet megjeleníteni vagy elküldeni egy megbízást, stb.). Egy függvénynek az az értelme, hogy a program alapvető szövegén kívülre viszi a kód egy logikailag összefüggő részét, és csak az ennek a részének szóló hívás marad a program alap szövegében. Az ilyen programszerkezetnek van néhány kétségbevonhatatlan előnye:

• először, azt a programszöveget, amit ilyen módon alkottak sokkal könnyebb olvasni;
• másodszor, könnyű átlátni és, ha szükséges, módosítani egy függvény szövegét anélkül, hogy a program alapvető kódjában bármilyen változást csinálnánk;
• harmadszor, egy függvényt egyetlen fájlként alkothatunk és használhatunk, és azt, ha szükséges a programozó egy másik programba  beillesztheti, és az új program részeként alkalmazhatja.

Azt mondhatjuk, hogy az MQL4 programokban levő kód legnagyobb részét már megírták függvényalakban.

Egy függvény létrehozása

Egy függvényt leírhatnak és hívhatnak. Figyeljünk meg egy példát! Tegyük fel, hogy nekünk van egy kicsi programunk (18. ábra) amelyik kiszámolja az átfogó hosszát, a derékszögű háromszög befogóiból a Pythagoras tétel használatával.

18. ábra. Az egyszerű program kódja  pifagor.mq4.

Ésszerű volna létrehozni egy függvényt, amely azt a két sort használja, ami a keresett értéket megtalálja. Az a program, ami egy függvényt használ látható a 19. ábrán.

19. ábra. Egy olyan program kódja, amely a felhasználói függvény leírását, és e függvény hívását is tartalmazza gipo.mq4.

A program mindkét verziója ugyanazt az eredményt fogja adni. Míg a kódot az első verzióban egyetlen modulként alkotjuk (18. ábra), ellenben a második verzióban (19. ábra) a számítások egy részét egy függvényben hajtjuk végre, amit az alapszövegből hívtunk. A különálló függvényben végrehajtott számítások befejezése után a számítások a fő kódban folytatódnak.

A függvény végrehajtásához nekünk hívnunk kell azt (hivatkozni kell rá). Ez az oka annak, hogy a függvény gyakorlatilag két részből áll: maga a kód, ami a függvényt alkotja  (függvényleírás) és a függvényhívás, ami elindítja a függvényt (utalás a függvényre). Ha nem hívod a függvényt, az nem hajtódik végre. Ugyanakkor, ha hívsz egy nem létező függvényt, az eredménytelen lesz (a MetaEditior   egy hibaüzenetet fog adni, ha megpróbálsz lefordítani egy ilyen MQL4 programot).

Függvényleírás

Egy függvény leírása két alapvető részből áll - függvényfejléc és függvénytörzs.

Egy függvény fejléce a visszaadott érték típusából, a függvény nevéből és a formális paraméterek listájából áll. A formális paramétereket listáját zárójelbe tesszük és a függvénynév után írjuk. A visszaadott érték típusa az egyik korábban ismertetett típus lehet: int, double, bool, color, datetime vagy string. Ha a függvény nem küld vissza értéket, a típusa void (tartalom nélkül), vagy bármilyen típust írhatunk.

Egy függvény törzsét kapcsos zárójellel nyitják. A függvénytörzs tartalmazhat egyszerű és/vagy összetett operátorokat és hívhat egyéb függvényeket. A függvény visszatérési értéke, a return() operátor zárójelei között szerepel. A visszatérési érték típusának, amit a return() operátor visszaküld, illeszkedni kell a függvényfejlécben megadott típussal. A függvény leírását kapcsos zárójelek fejezik be.

20. ábra. Függvényleírás.

Függvényhívás

Függvényhívás a függvény nevét és az átvitt paraméterek listáját jelenti. Az átvitt paraméterek listáját zárójelbe teszik. A függvényhívást egy különálló operátornak vagy egy operátor részeként tüntethetjük fel.

21. ábra. Függvényhívás (utalás egy függvényre).

A függvény típusok

Három fajta függvény van - különleges függvények, standard (beépített, előre definiált) függvények, és felhasználói függvények.

Különleges (speciális)  függvények

Az MQL4-ben összességében 3 különleges függvény van. Ezeknek előre definiált nevük van: init(), start(), és deinit(), ezeket a neveket nem használhatjuk semmilyen másik függvény neveként. A különleges függvények részletes vizsgálatát a  Különleges (speciális) függvények fejezetben találjuk. Itt csak megemlítjük, hogy egy program alapvető kódja ezekben a függvényekben helyezkedik el (18, 19. ábra).

A különleges függvények tulajdonsága, hogy őket az ügyfélterminál hívja, azért hogy ezeket végrehajtsa. Bár a különleges függvényeknek megvan a függvények minden általános tulajdonsága, őket általában nem hívjuk a programból, ha ezt a programot megfelelően kódoltuk.

Beépített (standard) függvények

Az MQL4 nem szűkölködik a beépített függvényekben, amelyeket a programok kódolás közben használhatunk. Például: négyzetgyököt számol, üzeneteket ír a rendszernaplóba vagy a képernyőre. A beépített függvényeket az előre definiált algoritmusuk szerint hajtja végre a program. A felhasználónak meg kell tanulnia ezeknek a függvényeknek a működését. Biztos lehet benne, hogy minden beépített függvényt megfelelően írtak meg a szakértők a lehetséges legjobb algoritmus szerint.

A beépített függvények sajátos jegye az, hogy őket nem írjuk le a program szövegében. A beépített függvényeket ugyanúgy hívjuk meg a programban, mint bármilyen más függvényt (ez az általános gyakorlat).

A példáinkban (18. és 19. ábra), két általános függvényt használtunk: MathSqrt() és Alert(). Az első feladata, hogy négyzetgyököt számoljon, míg a második feladata az üzenetközvetítés, a zárójelben lévő szöveg írja ki a képernyőre.

A beépített függvények tulajdonságait a Beépített (standart) függvények fejezet bekezdéseiben részletesen tárgyalni fogjuk. Észre fogjuk venni, hogy itt csak függvényhívásokat találunk, míg ezeknek a függvényeknek a leírását nem találjuk a programban. A beépített függvényeket nevezhetjük még általános, standard vagy előre definiált függvényeknek. Ezek közül a meghatározások közül bármelyiket használhatjuk.

Felhasználói függvények

Néhány esetben a programozók saját függvényeket írhatnak és használhatnak. Felhasználói függvényeknek nevezzük ezeket a függvényeket. Felhasználói függvények esetén a programokban szerepelni kell a függvényleírásnak és függvényhívásnak is.

1. táblázat. Függvényleírás és függvényhívás, a különböző típusú függvények használata a programokban.

(*) Bár különleges függvényeket technikailag hívhatunk egy programban, nem ajánlott ezt tenni.

A függvények tulajdonságai

Függvényvégrehajtás

Minden függvény fő tulajdonsága az, hogy a hívott függvényeket végrehajtják. A függvényeket a kódjaik szerint hajtják végre.

Átadott paraméterek és visszatérési érték

Az átadott és visszakapott információ vonatkozásában, egy függvény olyan, mint egy általános számológép. Beírsz (a billentyűzettel) egy olyan kifejezést, ami több értékből áll, és válaszként egy értéket fogsz kapni. Egy függvény egy vagy több paramétert dolgoz fel abból a programból ami hívta ezt a függvényt. A  függvény el fogja végezni a műveletet, és visszatér erre a programra a paraméterekre adott válasszal.

Az átadott paramétereket a függvény neve után zárójelbe téve részletezzük. Az átadott paramétereket vesszőkkel választjuk el. Az átadott paraméterek száma nem haladhatja meg a 64-et. A függvényhívás lehetséges akkor is, ha nem szerepelnek benne átadott paraméterek. Ebben az esetben a paraméterek üres listáját adjuk meg, vagyis közvetlenül a függvény neve egy nyitó és egy záró zárójelet teszünk.

A függvényhívásban levő átadott paraméterek számának, típusainak és sorrendjének meg kell egyeznie a formális paraméterekkel, amelyeket a függvényleírásban megadtunk. (Az olyan függvénynek szóló hívás, amely függvénynek alapértelmezett paraméterei vannak kivételt képez - lásd: Függvényhívás és Függvényleírás és a "return" operátor). Ha nem illeszkednek a paraméterek, a MetaEditor egy hibaüzenetet fog adni. Állandókat, változókat, kifejezéseket és tömböket használhatunk átadott paraméterekként. A visszatérési értéket a return() operátor zárójelei között adjuk meg (lásd: Függvényleírás és a "return" operátor).

A return() operátor által visszaküldött érték típusának illeszkednie kell a függvényfejlécben megadott típushoz. Az is lehetséges, hogy egy függvény nem küld vissza értéket. Ebben az esetben semmit nem írunk  return() operátor zárójeleibe.

A példánkban az átadott paraméterek A és B változók (21. ábra), míg a visszaadott érték C változó (20. ábra). Az átadott paraméterek és a formál paraméterek megfeleltetését láthatjuk a 22. ábrán.

22. ábra. Illeszkedik az átadott és a formális paraméterek száma, típusa és sorrendje. Egyedül változókat használtunk átadott paraméterekként.

23. ábra. Illeszkedik az átadott és formális paraméterek száma, típusa és sorrendje. Egy állandót, egy kifejezést, és a megfelelő típusú változókat használjuk átadott paraméterekként.

Formális paraméterek

A formális paraméterek használata függvények egy fontos tulajdonsága.

A formális paraméterek a változók egy listája, amelyeket a függvényleírás fejlécében részleteznek.

Mint már ezelőtt említettük, hogy egy függvényt több programban használhatnak. Azonban a különböző programok különböző változó neveket használnak. Ha a változók neveinek szigorú összeillesztést követelnénk meg a függvények használata során, ez nem lenne kényelmes a programozóknak. Valójában ekkor minden újonnan fejlesztett programban olyan változó neveket kellene használni, amiket már azelőtt a függvényekben használtak.  Azonban szerencsére a függvényekben használt változók neveinek nincs kapcsolatuk a programban használt változók neveivel.

Nézzük a 20. és 21. ábrát még egyszer! Vegyük észre, hogy az átadott paraméterek  nevei (A és B a függvényhívás zárójeleiben) nem eggyeznek a függvény leírásban részletezett paraméterek neveivel (a és b)!  Mint azt az Állandók és változók bekezdésben tárgyaltuk MQL4 nagybetű érzékeny. Így, a szóban forgó nevek A és a, B és b itt különböző változók nevei. Mindazonáltal ebben a kódban nincs hiba.

A függvényleírásban lévő változók (formális paraméterek) nem kapcsolatosak a változókkal, amiket a program alapvető kódjában használtak. Ezek különböző változók. A változókat, de nem az állandókat, formális paraméterekként meg lehet adni a függvény fejlécben.

Hogyan működik

• A programban, történik egy függvényhívás, A és B változókat részletezik a zárójelekben.
• A program hívja a neve alapján a függvényt, aminek formális paraméterei vannak, a és b a fejlécében részletezve.
• Az A változó értékét adja a változónak.
• A B változó értékét adja b változónak.
• Végrehajtja a függvény a számításokat, a és b változók értékeit használva.

Adhatunk a formális paramétereknek bármilyen nevet (ezek nem kell, hogy egybe essenek a változók neveivel, amiket a programban használtak). Ebben a példában a formális paraméterek azonosítására a-t és b-t használtuk. Használhatnánk bármi mást is például: m és n, vagy Kat_1 és Kat_2. Persze, mikor írod a programot ( a függvényt), a függvény törzsben a számítások során azokat a változó neveket kell használni, amely változó neveket a fejlécben megadtál. Ha a fejlécben a és b szerepel, akkor a függvénytörzsben is a-t és b-t kell használni és nem m-et és n-t.

Egy függvényben  a számításokat az  a és b formális paraméterekkel végzik és nem az A és B változókkal. Egy függvény, bármilyen műveletet  végrehajthat az a és b formális paramétereken (az ezeknek a változóknak az értékeiben bekövetkező változtatásokat  is beleértve). Azonban nincs hatása az A és B változókra.

A függvényben kiszámolt értéket visszakapjuk a return() operátor  zárójeleiben. Egy változó értékét, egy kifejezés eredményét, vagy egy állandót visszaadott értékként használhatunk. Az esetünkben  ez a c lokális változó értéke (lokális változó: egy változót egy függvényen belül deklarálnak; ha elhagyjuk a függvényt, minden lokális változó értéke el fog veszni; további részletet a lokális változókról A változók típusai részben fogunk találni). A függvény visszaadja a programnak a c lokális változó értékét (19. ábra). Ez azt jelenti, hogy ezt az értéket fogja kapni a C változó.

További számításokat végezhetünk a programban, ha szükséges, azokkal a változókkal, amelyeket a meghívott függvényen belül deklaráltak. Az esetünkben a hívó függvény a különleges start() függvény (ez tartalmazza azt sort, amely hívja a felhasználói függvényt), a hívott függvényen belül deklaráljuk az A, B, és C változókat. Ennél fogva, a függvényben a számításokat a formális paraméterekkel hajtjuk végre, melyek lehetővé teszik, hogy olyan függvényeket hozzunk létre, amelyek önkényes változóneveket használnak, függetlenül azoktól a változónevektől, amiket ténylegesen a fő programkódban használunk.

Példa: beépített függvény egy programban

Először is vizsgáljuk meg a 18. ábrán látható program viselkedését. Meg kell jegyezni, hogy a program egész kódja a start()  különleges függvényben helyezkedik el. Ennél a tanulási fázisnál nem fogunk különösen figyelni erre (a különleges függvényekről a Különleges Függvények fejezetben részletesen beszélünk).

Kövessük a program végrehajtását, ami egy értékadó operátorral kezdődik:

 int A = 3; // Első befogó
 

1. Az értékadó operátor jobb oldala tartalmazza az állandót, az értéke 3.
2. A 3 értéket (a jobb oldali rész értéke) megkapja az A változó (az egyenlőségjel bal oldala az értékadó operátorban). A vezérlést a következő sor kapja:

    int B = 4; // Második befogó

3. Az értékadó operátor jobb oldala tartalmazza az állandót, az értéke 4.
4. 4 értéket kapja a B változó. A program a következő sort végrehajtásába fog:

    int C_2 = A*A + B*B;  // A befogók négyzeteinek összege

5. Az értékadó operátor jobb oldalának a kiszámítása. A számítások eredménye a 25-ös érték (azt a módszert, hogy egy program hogyan használja a változókat, hogy az értéküket megkapja az  Állandók és változók részben fogjuk tárgyalni, úgyhogy itt most ezt nem részletezzük).
6. A C_2 változó a 25 értéket kapja. A következő sor tartalmaz egy értékadó operátort, aminek a jobb oldalán egy beépített függvénynek szóló hívás van:

    int C = MathSqrt( C_2); // Az átfogó kiszámítása

   A program arra törekszik, hogy végrehajtsa az értékadó operátort. Ezért először az egyenlőségjel jobb oldalán levő számításokat hajtja végre.

7. A program végrehajtást követel a MathSqrt() beépített függvénytől (ami négyzetgyökök számol). A C_2 változó értéke (most ez az érték egyenlő 25-tel) átvitt paraméterként fog szerepelni. Vedd észre, hogy ennek a beépített függvénynek a leírása nincs sehol a programban. A beépített függvények leírásainak nem kell a programokban elhelyezkedniük. Egy program szövegében könnyű megkülönböztetni a beépített függvényhívást: ezeket sötétkékkel emelik ki a MetaEditor (a programozó önkényesen megválaszthatja a színeket ).
8. A számításokat elvégzi az MathSqrt() beépített függvény.
9. A MathSqrt() beépített függvény befejezte a számításait, és visszaküldi a kiszámított értéket. Az esetünkben ez az 5 (a 25 négyzetgyöke).

   Az az érték, amit visszaküldött a függvény lesz most a rekord tartalma:

    MathSqrt( C_2)

   Ezt a rekordot felfoghatjuk egy különleges, összetett változóként, egy fajta dologként, amiben a számításokat végrehajtják. Miután ezeket a számításokat befejezték, ez a dolog felvesz egy értéket. Meghatározó itt az a tény, hogy ezt az értéket a függvény küldte vissza. Lehet ez az érték egy másik változó értéke vagy felhasználhatjuk bármilyen másik számításban.

10. Ebben az esetben az értékünk az értékadó operátor jobb oldalának az értéke. Az értékadó operátor végrehajtása során a program a C változó értéknek 5-öt fog adni.
11. A következő sorban található az az operátor, amelyik hivatkozik az Alert() beépített függvényre (függvényhívás).

     Alert("Az átfogó = ", C);  // Üzenet a képernyőn

    Az Alert()beépített függvény kinyit egy olyan  üzenetablakot, ahol ennek a függvénynek adott paramétereket láthatjuk. Ebben az esetben a függvény átadott paramétere két értéket tartalmaz:

    • a string állandó értékét: Az átfogó =
    • a C változó szám értékét: 5

Ismert, hogy nem minden függvények kell visszaküldenie az értékét (a függvényvégrehajtás eredményét). Az Alert() beépített függvény nem küld vissza értéket, mert ennek más feladata van – ennek egy szöveget kell mutatnia a képernyőn egy külön ablakban.

Az Alert(), beépített függvény végrehajtásának eredményeként ennek a függvénynek az ablakában a következő sor fog megjelenni:

Az átfogó = 5

12. Az utolsó operátor ebben a programban befejezi a különleges start() függvény munkáját.

     return; // Kilépés operátor

Ennél a pontnál a program munkája kész.

Egy kérdés felmerülhet: Hogyan fogjuk tudni, hogy kapunk-e visszatérési értéket, vagy nem? A válasz erre a kérdésre nyilvánvaló: A beépített függvények részletes leírását megtalálod, ha elovasod a  program dokumentációt  vagy tájékozódsz a  MQL4.community  és a MetaQuotes Software Corp. oldalakon és a MetaEditor Help-jében. Most egy felhasználói függvény tulajdonságait részletezzük. Hogy egy felhasználói függvény visszaküldi az értéket vagy nem, az az algoritmusától függ (a döntést a programozó hozza a függvény programkódjának az írása során).

Példa: felhasználói függvény egy programban

Figyeljük meg, hogy milyen számításokat végeznek abban a programban, ami egy felhasználói függvényt tartalmaz (19. ábra). A kód egy bizonyos része, amit korábban megtaláltunk a különleges start() függvényben most hiányzik. Azt lecserélték a felhasználói függvénynek szóló hívásra. Mindazonáltal a start() különleges függvény követi a felhasználói függvény leírását.

Az első két sor, amiben A és B egész számváltozók számszerű értékeket vesznek, ugyanaz marad. Következetesen semmi nem változik a végrehajtásukban:

 int A = 3; // Elsö befogó
 int B = 4; // Második befogó

A harmadik sorban van nálunk egy értékadó operátor. A jobb oldala tartalmazza a felhasználói függvénynek szóló hívást:

 int C = Gipo(A,B); // Az átfogó kiszámítása

6. Miközben végrehajtja ezt az operátort, a program először is hívni fogja a felhasználói függvényt.

Megjegyzés: A felhasználói függvény leírásának jelen kell lennie a programodban és a helye közvetlenül a különleges start() függvényt bezáró kapcsos zárójel után van (vagyis a (start) különleges függvényen kívül).

Miközben hívja a felhasználói függvényt, a program végre fogja hajtani a következőt:

6.1. Hivatkozik az A változóra, hogy megkapja az értékét, ( 3)

6.2. Hivatkozik az B változóra, hogy megkapja az értékét, (most ez 4)

Megjegyzés: Amint a program elkezdi hívni a felhasználói függvényt (a felhasználói függvény nem speciális eset; ez a szabály minden függvényre vonatkozik), a program megkapja a változók értékeinek másolatát, amiket átadott paraméterekként használ, de ezeknek a változóknak az értékei (ebben az esetben, A és B) a felhasználói függvény alkalmazása miatt nem változnak.

7. A vezérlést megkapja a felhasználói függvény.

A felhasználói függvény végrehajtásának a teljes ideje alatt (függetlenül attól, hogy ez milyen hosszú), a hívó programban levő változók az értékeiket nem fogják elveszteni, hanem tárolni fogják azokat.

Az első sor a felhasználói függvény leírásában a fejléc:

 int Gipo(int a, int b) // Felhasználói függvény

A felhasználói függvény végrehajtása alatt, a program a következőket fogja tenni:

7.1. A 3 értéket (az első érték az átadott paraméterek listájában) a változónak fogja kijelölni (az első változó a formális paraméterek listájában).

7.2. A 4 értéket (a második érték az átadott paraméterek listájában) b változónak fogja kijelölni (a második változó a formális paraméterek listájában).

Azután a vezérlést meg fogja kapni a függvénytörzs azért, hogy végrehajtsa az algoritmusát.

Az első operátor a függvénytörzsben:

 int c2 = a*a + b*b; // A befogók nényzeteinek összege

7.3. Miközben végrehajtja ezt az operátort, a program kiszámítja az értékadó operátor jobb oldalán lévő értéket, és az így kapott érték lesz a c2 változó értéke (jelenleg ez 3*3 + 4*4 = 25).

A következő operátor:

 int c = MathSqrt(c2); // Az átfogó

7.4. Itt keressük a c2 változó értékének a négyzetgyökét. A művelet ugyanaz, mint az előző példában. A beépített függvény leírását sehol nem kell megadni. Az értékadó operátor végrehajtása azzal fog végződni, hogy a c változó 5 értéket fog kapni.

7.5. A következő sorban operátor van:

 return(c); // Függvény kilépési (visszatérési) operátor

Miközben a program végrehajtja ezt az operátort, a program vissza fogja adni (a felhasználói függvény hívás oldalára) azon változó értékét, ami ennek az operátornak a zárójeleiben van. Jelen esetben a c változó értéke 5.

Ennél a pontnál a felhasználói függvény végrehajtásának vége van, az irányítást a hívás oldalnak adják.

8. Visszatérés oda, ahonnan a felhasználói függvényt hívta az operátor.

 int C = Gipo(A,B); // Átfogó kiszámítása

A

 Gipo(A,B)

rekord (a felhasználói függvényhívás) a visszatérő érték, felvesz azt az értéket, amit a függvényben kiszámoltunk (esetünkben értéke 5).

 Miközben befejezi az értékadó operátor végrehajtását, a program a C változónak az 5 értékét fogja adni.

9. A következő operátort

 Alert("Az átfogó = ", C); // Üzenet a képernyőn

a program ugyanúgy fogja végrehajtani, ahogy az előző példában, mégpedig: egy külön ablakban fog az üzenet megjelenni:

10. Az utolsó operátor ebben a programban a

 return; // Függvény kilépési operátor

befejezi a start(), különleges függvény munkáját és ezzel egyidejűleg befejezi az egész program munkáját (a különleges függvények tulajdonságait a Különleges függvények) részben fogjuk tárgyalni).

Lássunk néhány variációt a fenti felhasználói függvény megvalósítására! Könnyű belátni, hogy a programozás felhasználói függvényekkel való megvalósításának van néhány kétségbe vonhatatlan előnye.

A korábban megismert Gipo() felhasználói függvény megvalósítása

Ebben a függvényben a formális paraméterek hasonlítanak azokra a változókra, amiket az alap programban használtak. Azonban ez csak egy látszólagos hasonlóság, mert A és a különböző változók nevei.

//-----------------------------------------------------------------------
int Gipo(int a, int b) // Felhasználói függvény
 {
 int c2 = a*a + b*b; // A befogók négyzeteinek összege
 int c = MathSqrt(c2); // Átfogó
 return(c); // Függvény kilépési operátor
 }
//-----------------------------------------------------------------------

A Gipo() felhasználói függvény megvalósítása: 2. verzió

Ebben az esetben a formális paraméterek nevei nem hasonlítanak azon változók neveire, amiket az alapvető programban használtunk. Ez nem akadályozza meg, hogy használjuk ezt a függvényt a programban.

//--------------------------------------------------------------------
int Gipo(int alpha, int betta) // Felhasználói függvény
 {
 int SQRT = alpha*alpha + betta*betta; // A befogók négyzeteinek összege
 int GIP = MathSqrt(SQRT); // Átfogó
 return(GIP); // Függvény kilépési operátor
 }
//--------------------------------------------------------------------

A Gipo() felhasználói függvény megvalósítása: 3. verzió

Ebben a példában az alfa változót újra felhasználjuk a programban és kétszer is megváltoztatja az értékét. Ennek a ténynek nincs hatása azokra a változókra, amiket a főprogram függvényhívásában megadtak.

//--------------------------------------------------------------------
int Gipo(int alpha, int betta) // Felhasználói függvény
 {
 alpha= alpha*alpha + betta*betta; // A befogók négyzeteinek összege
 alpha= MathSqrt(alpha); // Átfogó
 return(alpha); // Függvény kilépési operátor
 }
//--------------------------------------------------------------------

A Gipo() felhasználói függvény megvalósítása: 4. verzió

Ebben a felhasználói függvényben minden számítást egy operátorban gyűjtenek. A visszaadott értéket közvetlenül a return() operátor zárójeleiben számolják ki. Ez a megoldás először furcsa és hibásnak tűnik. Mindazonáltal nincs hiba a felhasználói függvénynek ebben a megvalósításában. Az operátorok száma, amit ebben a függvényben használtak, kisebb mint a másik megvalósításokban tehát a kódról kiderült, hogy tömörebb.

//--------------------------------------------------------------------
int Gipo(int a, int b) // Felhasználói függvény 
 {
 return(MathSqrt(a*a + b*b)); // Függvény kilépési operátor
 }
//--------------------------------------------------------------------

Tehát a felhasználói függvények alkalmazásának van néhány kétségbevonhatatlan előnye a programozási gyakorlatban:

• a program alapszövegében levő változók neveinek nincs kapcsolata a formális paraméterek neveivel a felhasználói függvényben;
• a felhasználói függvények különböző programokban újra használhatók, nem szükséges megváltoztatni a felhasználói függvény kódját;
• ha szükséges függvénykönyvtárakat hozhatunk létre.

A függvényeknek ezek a nagyon hasznos tulajdonságai teszik lehetővé egy vállalatnál az igazán nagy programok létrehozását. Több programozó tud egyidejűleg résztvenni ebben a folyamatban, nem kell egyeztetniük a felhasznált változók neveit. Az egyetlen dolog, amit egyeztetniük kell az a változók sorrendje a függvényfejlécben és a függvényhívásban.