Függvényhívás

 Function_name (Paraméterek); // Egy függvényhívás

Annak a függvénynévnek amit a függvényhívásban megadunk ugyanannak kell lennie, mint annak a függvénynek a neve, amit végrehajtásra hívunk. A paramétereket a listában vesszőkkel választjuk el. Az átadott paraméterek száma korlátozott és nem lehet több 64-nél. Egy függvényhívásban paraméterként lehet használni állandókat, változókat és másik függvényhívásokat. A függvényhívásban levő átadott paraméterek számának, típusainak és sorrendjének ugyanannak kell lenniük, mint a formális paraméterek száma, típusai és sorrendje, amelyeket a függvényleírásban megadtak, (kivétel ha a függvényhívás a függvény alapértelmezett paramétereivel történik).

My_function (Alf, Bet) // Példa a függvényhívásra
 // Ahol:
My_function // A hívott függvény neve
Alf  // Az első átadott paraméter
Bet // A második átadott paraméter

Ha a hívott függvény nem igényel átadott paramétereket, a paraméterek listája üres, de a zárójeleket ki kell tenni.

My_function ()  // Példa a függvényhívásra
 // Ahol:
My_function  // A hívott függvény neve
() // Nincs átadott paraméter

Ha a programnak egy függvényt az alapértelmezett paraméterekkel kell hívnia, az átadott paraméterek listája hiányos lehet (megrövidített). Ha nem adunk új érték a függvény minden alapértelmezett paraméterének, akkor az átadott paraméterek társítását az első alapértelmezett paraméterrel kezdjük. A lenti példa az a b, c, és d lokális változók néhány értékét mutatja:

 // A függvény leírása a következő:
int My_function (int a, bool b=true, int c=1, double d=0.5)
 {
 Operátorok
 }
 // .. a következő függvényhívások lehetségesek:
My_function (Alf, Bet, Ham, Del) // Lehetséges függvényhívás
My_function (Alf )  // Lehetséges függvényhívás
My_function (3) // Lehetséges függvényhívás
My_function (Alf, 0) // Lehetséges függvényhívás
My_function (3, Tet)  // Lehetséges függvényhívás
My_function (17, Bet, 3)  // Lehetséges függvényhívás
My_function (17, Bet, 3, 0.5) // Lehetséges függvényhívás

Ha egy paraméternek nincs alapértelmezett értéke akkor annak megadását a függvényhívásbanl nem hagyhatjuk el. Ha egy alapértelmezett paraméter kimarad, a következő alapértelmezett paramétereket sem lehet megadni.

 // A függvény leírása a következő:
int My_function (int a, bool b=true, int c=1, double d=0.5)
{
 Operátorok
}
 // ..a következő függvényhívások hibásak:
My_function () //Hibás függvényhívás: a nem alapértelmezett ..
 // ..paraméterek nem hagyhatók el(a legelső)
My_function (17, Bet, , 0.5) // Hibás függvényhívás: kimaradt egy.. 
 // ..alapértelmezett paraméter (a harmadik, majd a következő új értéket kap)

A hívott függvények két csoportba oszthatók: azokra, amelyek visszaküldik egy előre definiált típus egy bizonyos értékét és azokra, amelyek nem küldenek vissza értéket.

A  visszatérési értéket nem szolgáltató függvény hívásának formátuma

Egy olyan függvénynek szóló hívást, amely nem küld vissza értéket csak különálló operátorként hozhatunk létre. A függvényhívás operátort a ";” (pontosvessző) fejezi be:

Function_name (Paraméter_lista); // Egy olyan függvénynek szóló hívás, amely nem küld vissza értéket
egy operátorként létrehozva

Func_no_ret (Alpha, Beta, Gamma);  // Példa egy olyan függvényhívás operátorra..
  //.. ahol a hívott függvény nem küld vissza értéket 

Nincs másik módszer (technika) olyan függvények hívására, amelyek nem küldenek vissza semmilyen értékeket.

A  visszatérési értéket  szolgáltató függvények hívásának formátuma

Egy olyan függvénynek szóló hívást, ami egy értéket küld vissza létrehozhatunk különálló operátorként, vagy azt használhatjuk a programkódban olyan helyeken, ahol egy bizonyos típusú értékre utalunk.

Ha a függvényhívást különálló operátorként alkalmazunk, akkor az pontosvesszővel végződik:

Function_name (Paraméter_lista); // Értéket visszaküldő függvény hívása
mint operátor

Func_yes_ret (Alpha, Beta, Delta);  //Példa egy olyan függvény hívására..
  //.. amely függvény értéket küld vissza

A függvényhívás végrehajtási szabályai

Másik operátorokban levő függvényhívások használatát meghatározza ezeknek az operátoroknak a formátuma.

A lenti példa, a  callfunction.mq4 script a következőket tartalmaz. Egy függvényhívást az operátor fejlécében (1.Kifejezés a 'for' operátor formátuma szerint, lásd:  'for' ciklusoperátor), egy beépített függvény hívását különálló operátorként, az értékadó operátor jobb oldalán (lásd: Értékadó operátor), és egy függvényhívást az 'if-else' operátor fejlécében (a Feltétel az 'if-else' operátor formátuma szerint, lásd: 'if-else' feltételes operátor).

///-----------------------------------------------------------------------------------
// callfunction.mq4
// The code should be used for educational purpose only.
//------------------------------------------------------------------------------------
int start() // Description of function start()
 { // Start of the function start() body
 int n; // Variable declaration
 int T=15; // Predefined time
 for(int i=Func_yes_ret(T);i<=10;i++) // The use of the function in..
  //.the cycle operator header
 { // Start of the cycle 'for' body
 n=n+1; // Iterations counter
 Alert ("Iteration n=",n," i=",i); // Function call operator
 } // End of the cycle 'for' body
 return; // Exit function start()
 } // End of the function start() body
//-------------------------------------------------------------------------------------
int Func_yes_ret (int Times_in) // Description of the user-defined function
 { // Start of the user-defined function body
 datetime T_cur=TimeCurrent(); // The use of the function in.. 
  // ..the assignment operator
 if(TimeHour(T_cur) > Times_in) // The use of the function in.. 
  //..the header of the operator 'if-else'
 return(1); // Return value 1
 return(5); // Return value 5
 } // End of the user-defined function body
//-------------------------------------------------------------------------------------

A fenti példában a lévő függvényeket a következő átadott paraméterekkel hívtuk:

• a Func_yes_ret(T) függvény hívása - T változó;
• az Alert () függvény hívása - ”Iteration n=” és ”i=” string állandók, valamint n és i változók;
• a TimeCurrent() függvény hívása nem ad át paramétert;
• a TimeHour(T_cur) függvénynek szóló hívás - a T_cur változót adja át paraméterként.

Egy nagyon egyszerű algoritmust valósítunk meg ebben a programban. A számításaink alapja a T változó az idő (órákban).  A 'for' operátor fejlécében, helyeztük el a Func_yes_ret() felhasználói függvénynek szóló hívást, amely két érték valamelyikét küldheti vissza: 1 vagy 5. a visszaküldött érték szerint a ciklusban levő ismétlések száma változni fog: lehet 10 (1-től 10-ig) vagy 6 (5-től 10-ig). Jobb megjelenítés érdekében a ciklustestben használjuk a számlálót, melynek mindegyik értékét kijelzi a képernyőn az Alert() függvényt.

A felhasználói függvény leírásában először másodpercekben számoljuk az 1970. január 1-je 00:00, óta eltelt időt (TimeCurrent() függvény hívása), azután órákban kiszámítjuk az aktuális időt (TimeHour() függvény hívása). Az algoritmust elágaztatjuk az 'if' operátorral (a TimeHour() függvényhívás a feltételében szerepel). Ha az aktuális idő (Times_in helyi változó) több, mint amit paraméterként (T) elküldtünk a felhasználói függvénybe, a függvény visszatérési értéke1, máskülönben a visszatérési érték 5.

Kérlek jegyezd meg:

Lent láthatod a  callfunction.mq4 script blokkdiagramját:

51. ábra. A program blokkdiagramja függvényhívások használatával.

A körök a diagramban függvényhívásokat jelölnek (a standard és felhasználói függvények). A vörös nyilak a vezérlés átadást mutatják a függvényben oda és vissza. Világosan látható, hogy a függvény visszaküldi a vezérlést oda, ahonnan a függvényhívás érkezett, nincsenek számítások a függvényhívás és a függvény közötti útvonalon. Általában, ha egy függvény visszaküld egy értéket, ezt az értéket a hívó modul kapja (a piros nyíl mentén a függvényhívás irányában).

Különleges függvényeket ( init(), start(), deinit()), az általános szabály szerint a programban bárhonnan hívhatunk, e tekintetben a többi függvénnyel egyenlők. A különleges függvényeknek szintén lehetnek paramétereik. Mindazonáltal, amikor az ügyfélterminál hívja ezeket a függvényeket, paramétereket nekik nem fog kívülről küldeni, az alapértelmezett értékeket fogja használni. A különleges függvényekben levő paraméterek használata csak akkor lesz ésszerű, ha őket egy programból hívjuk. Bár technikailag lehetséges, hogy a különleges függvényeket hívjunk egy programból, ez nem ajánlott. Meg kell fontolni egy programból a különleges függvényhívások használatát: ez helytelen.