Radu MetaTrader a blogja | További ingyenes és hasznos eszközök MetaTraderhez | Kérdésed merült fel? Kérdezz!
MQL4 Könyv tartalomjegyzék | Stratégiák programozása MetaTrader platformra | Fogalomtár | Gyakran Ismételt Kérdések

MQL4 könyv   Operátorok    Fűggvényhívás


Függvényhívás

 

Egy függvényhívást egy különálló operátorként használhatunk, és bárhol lehet a programban ahol egy bizonyos értékre utal (az előre definiált esetek kivételével). A függvényhívás formátum és a végrehajtás szabályai a standard (beépített) és felhasználói függvények esetén is azonos.

A függvényhívás formátum

 

Egy függvényhívás a függvény névből és az átadott paraméterek listájából áll, amit zárójelek közé zárunk:

 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

Egy függvényhívás neve azonos annak a függvénynek a nevével, amelyet végrehajtásra hív. Ha a függvényhívást különálló operátorként alkalmazzuk, miután a függvény végrehajtódott, a vezérlést átadják annak az operátornak, amely követi a függvényhívást. Ha a függvényhívást egy kifejezésben használjuk, miután a függvény végrehajtódott a vezérlés visszakerül abba a kifejezésbe, ahonnan a függvényhívást elindítottuk; a további számításokat ebben a kifejezésben a függvény visszatérési értékének használatával fogjuk elvégezni.

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

20 feladat: Alkoss egy olyan programot, ahol a következő feltételeket teljesítjük:
- ha az aktuális idő több mint 15:00, 10 ismétlést hajtunk végre a ciklusban;
- minden más esetben 6 ismétlést hajtunk végre.

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:

A standard (beépített) függvényeknek nincs leírása és a start() függvénynek  nincs függvényhívása a programban.

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.