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:

Figyelem!

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:

Figyelem!

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

Figyelem!

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.