Az MQL4 programozási nyelv

Operátorok

Az 'if-else' feltételes operátor

Az ’if-else’ operátor teljes formátuma tartalmaz egy fejlécet a feltétellel, az 1. operátortörzset az 'else' kulcsszóval, és a 2. operátortörzset. Az operátortörzsek egy vagy több operátorból állhatnak; az operátortörzseket kapcsos zárójelek határolják.

Teljes formátum:

if ( Feltétel ) // Az operátor fejléce a feltétellel { 1. operátor blokk // Ha a Feltétel igaz(true), akkor.. }else // Ha a Feltétel hamis(false) akkor.. { 2. operátor blokk }

Az else, vagy akár a kapcsos zárójelek is elhagyhatók:

if ( Feltétel ) // Az operátor fejléce a feltétellel Operator; // Ha a feltétel igaz ez az operátor végrehajtódik.

A 'while' ciklus operátor

A ‘while’ ciklus-operátor teljes formátuma a fejlécből, -ami egy feltételt tartalmaz, és a kapcsos zárójelek közé zárt végrehajtható ciklustörzsből áll.

while ( Feltétel ) { Operátor blokk }

Ha az operátortörzs csak egy operátorból áll a ‘while’ operátorban a kapcsos zárójelek elhagyhatók:

while ( Feltétel ) operator;

A 'for' ciklusoperátor

A 'for' ciklusoperátor teljes formátuma áll - a fejlécből, ami tartalmazza az 1.Kifejezést a Feltételt és a 2.Kifejezést - és áll a végrehajtható ciklustörzsből, amelyet kapcsos zárójelek közé zárunk.

for (1.Kifejezés; Feltétel; 2.Kifejezés) // Ciklusoperátor fejléc { Operátor blokk }

Ha a 'for' operátorban a ciklustörzs csak egy operátorból áll a zárójeleket elhagyhatjuk:

for (1.Kifejezés; Feltételt; 2.Kifejezés) // Ciklusoperátor fejléc Egy operátor a ciklustörzs

Az 1.Kifejezés a Feltétel és a 2.Kifejezés hiányozhatnak a kódból. Azonban az elválasztó karakternek ";” (pontosvessző) maradnia kell a kódban:

for ( ; Feltétel; 2.Kifejezés) // Nincs 1.Kifejezés { Operátor blokk.. } // - --------------------------------------------------------------------------------- for (1.Kifejezés; ; 2.Kifejezés) // Nincs Feltétel { Operátor blokk.. } // - --------------------------------------------------------------------------------- for ( ; ; ) // Nincsenek Kifejezések sem Feltétel { Operátor blokk.. }

A 'break' és 'continue' operátorok

Az MQL4-ben is létezik a megszokott break és continue operátor. A break segítségével megállíthatjuk a ciklust, mielőtt még a feltétel hamissá válna, a continue segítségével pedig befejezhetjük az adott iterációt és átléphetünk a következőre.

if (s <= S ) break; if (One_Farm < One_Farm_max) continue; //

A 'switch' operátor

A 'switch' operátor a fejlécből és a végrehajtható testből áll. A fejléc tartalmazza az operátor nevét és egy zárójelbe zárt kifejezést. Az operátortörzs egy vagy több 'case' variációt tartalmaz, valamint az alapértelmezett ‘default' variációt. Mindegyik 'case' variáció a 'case' kulcsszóból, egy állandóból, egy ’:’ (kettőspontból), és operátorokból áll. A 'case' variációk száma nem korlátozott. A ‘default' (alapértelmezett) variáció a 'default' kulcsszóból, ’:’ (kettőspontból), és operátorokból áll. Általában a 'default' variációt a 'switch' operátor törzsében utolsóként helyezzük el, de azt bárhol lokalizálhatjuk az operátortörzsön belül, vagy akár hiányozhat is. A Kifejezés és a parameterek értékei csak int típusú értékek lehetnek. A Kifejezés egy állandó, egy változó, egy függvényhívás vagy egy kifejezés lehet. A 'case' variációk lehetnek: egész számállandók, karakterállandók vagy állandókat tartalmazó kifejezések. Az állandó kifejezés nem tartalmazhat változókat vagy függvényhívásokat.

switch ( Kifejezés ) // Operátor header { case Paraméter: Operátorok // Egy 'case' variáció case Paraméter: Operátorok // Egy 'case' variáció ... [default: Operators] }

Például:

switch(Delta) // Header of the 'switch' { // Start of the 'switch' body case 1 : Alert("Plus one point"); break;// Variations.. case 2 : Alert("Plus two points"); break; case 3 : Alert("Plus three points"); break; case 4 : Alert("Plus four points"); break;//Here are presented case 5 : Alert("Plus five points"); break;//10 variations 'case', case 6 : Alert("Plus six points"); break;//but, in general case, case 7 : Alert("Plus seven points"); break;//the amount of variations 'case' case 8 : Alert("Plus eight points"); break;//is unlimited case 9 : Alert("Plus nine points"); break; case 10: Alert("Plus ten points"); break; default: Alert("More than ten points"); // It is not the same as the 'case' } // End of the 'switch' body

Függvényhívás, függvényleírás és a 'return' operátor

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. 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);

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). 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ásban nem hagyhatjuk el. Ha egy alapértelmezett paraméter kimarad, a következő alapértelmezett paramétereket sem lehet megadni. 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. 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, míg 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.

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 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). A függvényekben a paramétereknek lehetnek olyan alapértelmezett értékeik, amelyeket a megfelelő típusú állandó határoz meg. 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.

Példa függvényekre:

///----------------------------------------------------------------------------------- // 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 '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.