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ényleírás és 'return' operátor


Függvényleírás és 'return' operátor

 

Ha azalapján csoportosítjuk a függvényeket, hogy kell-e a programban függvényleírás, akkor 2 csoportba oszthatjuk őket: Olyan függvényekre, amelyeket nem írnak le egy programban, és olyan függvényekre, amelyeket le kell írni a programban. Standard (beépítetett) függvényeket nem írnak le a programokban. A felhasználói függvényeket le kell leírni minden programban. A különleges függvényeket, ha van ilyen, szintén le kell írni a programban.

A függvényleírás formátuma

 

Egy függvényleírás két alapvető részből áll: függvényfejléc és függvénytörzs.

A függvényfejléc tartalmazza a visszaadott érték fajtáját (típusát), a függvény nevét, és a formális paraméterek listáját, amelyeket zárójelbe teszünk. Ha egy függvénynek nem szabad visszaküldenie értéket, a típusának a neve void.

A függvénytörzs egyszerű és/vagy összetett operátorokból és másik függvényeknek szóló hívásokból állhat, és kapcsos zárójelbe tesszük.

A visszatérési érték típusa Függvény_név (A formál paraméterek listája)//Fejléc
{ // Nyitó kapcsos zárójel
A program kód // A függvénytörzs operátorokból ..
alkotja a //.. és más függvényeknek szóló ..
függvény törzset //.. függvényhívásokból állhat
} // Záró kapcsos zárójel

A paramétereket a listában vesszők választják el. A függvény paraméterek száma korlátozott és nem lehet több 64-nél. Formális paraméterekként a függvényfejlécben csak változókat szabad használni (nem lehetnek állandók, másik függvényhívások vagy kifejezések). Az függvényhívásban levő átadott paraméterek számának, fajtájának és sorrendjének ugyanannak kell lennie, mint a függvényleírásban részletezett formális paraméterek száma fajtája és sorrendje (az egyetlen kivétel az olyan függvénynek szóló hívás, amely függvénynek alapértelmezett paraméterei vannak):

int My_function (int a, double b) // Példa a függvény leírásra 
{
int c = a * b + 3; // Függvénytörzs operátor
return (c); // Függvény visszatérési operátor (kilépés a függvényből)
}
// Ahol (a fejléc balról jobbra):
int // A visszatérési érték típusa
My_function // A függvény neve
int a // Az első formál paraméter 'a' típusa: int
double b // A második formál paraméter 'b' típusa: double

A függvényekben a paramétereknek lehetnek olyan alapértelmezett értékeik, amelyeket a megfelelő típusú állandó határoz meg:

int My_function (int a, bool b=true, int c=1, double d=0.5)//Példa a függvény leírásra
{
a = a + b*c + d2; // Függvénytörzs operátor
int k = a * 3; // Függvénytörzs operátor
return (k); // Függvény visszatérési operátor
}
// Ahol (a fejléc balról jobbra):
int // A visszatérési érték típusa
My_function // A függvény neve
int a // Az első formál paraméter 'a' típusa: int (alapértelmezett értéke nincs)
bool b // A második formál paraméter 'b' típusa: double
true // A 'b' formál paraméter alapértelmezett értéke egy állandó
int c // A harmadik formál paraméter 'c' típusa: int
1 // A 'c' formál paraméter alapértelmezett értéke egy állandó
double d // A negyedik formál paraméter 'd' típusa: double
0.5 // A 'd' formál paraméter alapértelmezett értéke egy állandó

a,b,c,d,k // Helyi változók (hatókörük csak ez a függvény)

Ha  paraméterekkel rendelkező függvényhívással hívunk egy alapértelmezett értékekkel rendelkező függvényt, akkor a hívásban szereplő aktuális paraméterekkel lesz a függvény végrehajtva. Ha nincsenek aktuális paraméterek a függvényhívásban, akkor az alapértelmezett értékekkel rendelkező függvények az alapértelmezett értékekkel lesznek végrehajtva.

A különleges függvényeknek szintén lehetnek paramétereik. Mindazonáltal, az ügyfélterminál nem ad semmilyen paramétert kívülről, amikor hívja ezeket a  függvényeket, éppen ezért ezek az alapértelmezett értékeket használják. A különleges függvényeket szintén bárhonnan hívhatjuk,  az általános  szabály szerint ezek a többi függvényekkel egyenrangúak.

A függvényvégrehajtás szabályai

 
A függvényleírás helye egy programban:

A függvényleírást bármilyen másik függvényen kívül, külön kell elhelyezni a programodban (nem szabad egy másik függvényen belül elhelyezni).


Függvényvégrehajtás:

Egy függvényhívás végrehajtása annak a kódnak a végrehajtását jelenti, amely kód a függvény törzsét alkotja.

A 'return' operátor formátuma

 
A függvény visszatérési értéke annak a paraméternek az értéke, amit a 'return' operátor zárójeleiben, megadtunk. A 'return’ operátor a 'return' kulcsszóból és a zárójelbe tett kifejezésből (Expression) áll, és pontosvessző karakterben végződik. A 'return' operátor teljes formátuma:

 return (Expression);   // Operator return

A zárójelben egy kifejezés egy állandó, egy változó vagy egy függvényhívás is lehet. Az visszatérési érték fajtájának a 'return' operátor használta során ugyanannak kell lennie, mint amit megadtak a függvényfejlécben. Ha ez nem így van, a 'return' operátorban visszaküldött kifejezés típusát módosítani kell (typecasting), a függvényleírás fejlécében megadott típusra. Ha a typecasting lehetetlen a Meta Editor egy hibaüzenetet fog adni a program fordítása során.

A 'return' operátor végrehajtásának szabályai

A 'return' operátor leállítja a legközelebbi külső függvény végrehajtását és átadja a vezérlést a hívó programrésznek azok szerint a szabályok szerint, amiket meghatároztunk a függvényhíváskor. A függvény visszatérési értéke annak a kifejezésnek az értéke, amit megadtunk a ‘return' operátorban. Ha a paraméterérték típusa, amit megadtunk a 'return' operátorban, más, mint függvényfejlécben megadott típus, akkor azt módosítani kell a függvényfejlécben megadott visszatérési érték típusra.


Egy példa arra, hogy hogyan lehet használni a 'return' operátort:

bool My_function (int Alpha)  // Egy felhasználói függvény leírása
{ // A függvénytörzs kezdete
if(Alpha>0) // 'if' operátor
{ // Az 'if' operátortörzs kezdete
Alert("The value is positive"); // Beépített függvény hívása
return (true); // Az első kijárat a felhasználói függvényből
} // Az 'if' operátortörzs vége
return (false); // A második kijárat a felhasználói függvényből
}
// A függvénytörzs vége


Ha egy függvény visszaadott értéke void típusú, a 'return’ operátort kifejezés nélkül kell használni:

 return;   // Operator 'return' without the expressions in parentheses


Egy példa a 'return' operátor visszaadott érték nélküli használatára:

void My_function (double Price_Sell)               // Description of the user-defined function
  {                                                // Start of the function body
   if(Price_Sell-Ask >100 * Point)                 // Operator 'if'
      Alert("Profit for this order exceeds 100 п");// Standard function call
   return;                                         // Exit function
  }                                                // End of the function body


Lehetséges, hogy egy függvényleírás nem tartalmazza a 'return' operátort. Ebben az esetben a függvény automatikusan be fog fejeződni, amint (az algoritmus szerint) az utolsó operátort is végrehajtják a függvénytestben. Egy példa a 'return' operátor nélküli függvényleírására:

void My_function (int Alpha) // Description of the user-defined function
{ // Start of the function body
for (int i=1; i<=Alpha; i++) // Cycle operator
{ // Start of the cycle body
int a = 2*i + 3; // Assignment operator
Alert ("a=", a); // Standard function call operator
} // End of the cycle body
} // End of the function body


Ebben az esetben, a függvény abban a pillanatban be fog fejeződni, amikor a 'for' ciklusoperátor végrehajtása véget ért. Az utolsó művelet a függvény végrehajtásban a ciklusoperátor feltételének tesztelése lesz. Amint a Feltétel a ciklusoperátor fejlécében hamissá válik, a vezérlés a ciklusoperátoron kívül kerül. Mivel a függvény testében levő utolsó végrehajtható operátor, ez a ciklusoperátor, a  My_function () felhasználói függvény be fog fejeződni,és a vezérlés a függvényen kívülre kerül, oda ahonnan a  függvényt hívtuk.