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

 if ( Feltétel )   // Az operátor fejléce a feltétellel
{
 Az 1. operátor blokk // Ha a Feltétel igaz(true), akkor..
 alkotja az 1. operátortörzset //..az 1. operátor blokk kerül végrehajtásra
}else // Ha a Feltétel hamis(false) akkor..
akkor. {
 A 2. operátor blokk // ..a 2. operátor blokk kerül..
 alkotja a 2. operátortörzset // ..végrehajtásra
}

Formátum az 'else' nélkül 

Az ‘if-else’ operátor használható az 'else' rész nélkül is.  Ebben az esetben, az ‘if-else’ operátor tartalmazza a fejlécét a feltétellel és az 1. operátortörzset, amely kapcsos zárójelekkel határolt és egy vagy több operátorból áll.

 if ( Feltétel )   // Az operátor fejléce a feltétellel
{
Az 1. operátor blokk // Ha a Feltétel igaz(true), akkor..
 alkotja az 1. operátortörzset //..az 1. operátor blokk kerül végrehajtásra
} 

Formátum a kapcsos zárójelek nélkül 

Ha az ‘if-else’ operátortörzs csak egy operátorból áll, a kapcsos zárójelek 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.

Az ‘if-else’ operátor működési szabályai

Példák az ‘if-else’ operátor működésére

Találjunk néhány olyan példát, ahol be tudjuk mutatni az ‘if-else’ operátor használatát.

Egyféle megoldás lehet erre a problémára például következő : (onelevel.mq4):

//---------------------------------------------------------------------------------------
// onelevel.mq4
// The code should be used for educational purpose only.
//---------------------------------------------------------------------------------------
int start() // Special function 'start'
 {
 double
 Level, // Alert level
 Price; // Current price
 Level=1.2753; // Set the level
 Price=Bid; // Request price
//---------------------------------------------------------------------------------------
 if (Price>Level) // Operator 'if' with a condition
 {
 Alert("The price has exceeded the preset level");// Message to the trader
 }
//---------------------------------------------------------------------------------------
 return; // Exit start()
 }
//---------------------------------------------------------------------------------------

Először is ismerjük fel, hogy ezt a programot Expert Advisorként hozták létre. Ez arra utal, hogy a program hosszú időn át működni fog azért, hogy a szükséges üzenetet be tudja mutatni a képernyőn, amint az ár átlépi az előre beállított szintet. A programnak csak egy különleges függvénye van, a start(). A függvény kezdetén a változókat deklarálják és magyarázzák. Azután megadják a riasztási árszintet és az aktuális árat kérik.

Az ‘if-else’ operátort a programban a következő sorokban használják:

//---------------------------------------------------------------------------------------
 if (Price>Level) // Az 'if' operátor a feltétellel
 {
 Alert("The price has exceeded the preset level");// Message to the trader
 }
//---------------------------------------------------------------------------------------

Amint a program átadja a vezérlést az ‘if-else’ operátornak a program tesztelni fogja a feltételt. Jegyezd meg, hogy a feltétel vizsgálata az ‘if-else’ operátorban ennek az operátornak a jellemző tulajdonsága. Ezt a vizsgálatot nem hagyhatja ki az ‘if-else’ operátor a végrehajtása alatt, ez egy elengedhetetlen követelmény, amit az operátor minden esetben végre fog hajtani. Majd ennek a vizsgálatnak az eredménye alapján fogja a vezérlést továbbadni valamelyik operátortörzsnek vagy a következő külső operátornak.

37. ábra: blokkdiagram az ‘if-else’ operátor végrehajtásával az onelevel.mq4 programban.

Ebben és minden következő diagramban egy rombusz képviseli a feltétel vizsgálatát. A nyilak mutatják a az aktuális blokk végrehajtása után vezérlés átadás irányát. Vizsgáljuk meg a diagramot alaposan!

 double
 Level, // Alert level
 Price; // Current price
 Level=1.2753; // Set the level
 Price=Bid; // Request price

Miután az utolsó operátort ebben a blokkban végrehajtották, vezérlést átadják az ‘if-else’ operátor fejlécébe hol a feltételt ellenőrzik: az ár felülmúlja az előre beállított szintet? (rombusz 37. ábra diagramjában).

 if (Price>Level) // Operator 'if' with a condition

Más szóval azt mondhatjuk, hogy a program ezen szakaszában következő kérdésre keressük a választ: A zárójelben lévő kijelentés igaz? Maga a kijelentés szó szerint így hangzik: A Price változó értéke nagyobb, mint a Level változó (az ár meghaladta az előre beállított szintet). Az ellenőrzés pillanatában a program már ismerte a Price és Level változók számszerű értékeit. A válasz ezen értékek viszonylatától függ. Ha az ár az előre beállított szint alatt van (az ár értéke kevesebb vagy egyenlő a Level értékénél), a kijelentés hamis; ha az ár felülmúlja ezt a szintet, a kijelentés igaz.

Hová kerül a vezérlés, miután a feltétel eredménye az aktuális piaci helyzettől függ (!). Ha egy szimbólum ára  az előre beállított szint alatt marad (a válasz, Nem, vagyis a kijelentés hamis), az vezérlés az ‘if-else’ operátor végrehajtási szabálya szerint, az operátoron kívül fog kerülni ebben az esetben a ”Következő számítás” blokkba, mégpedig a következő sorba:

 return; // Exit start()

Könnyű belátni, hogy a kereskedő nem kapott üzenetet.

Ha egy szimbólum ára meghaladja az előre beállított szintet a programban (a válasz Igen, a kijelentés igaz), a vezérlés át fog kerülni az ‘if-else’ operátor törzsébe, mégpedig a következő sorba:

 {
 Alert("The price has exceeded the preset level");// Message to the trader
 }

Az Alert()  függvény végrehajtása nyitni fog a képernyőn egy riasztási ablakot, ami a következő üzenetet tartalmazza:

Az Alert() függvény az egyetlen operátor az ‘if-else’ operátor törzsében, ezért az Alert() függvény végrehajtása után, az ‘if-else’ operátor teljesen végrehajtódott, és a vezérlés átkerül arra az operátorra, ami az ‘if-else’ operátort követi:

 return; // Exit start()

Az 'return' operátor végrehajtása azzal végződik, hogy a start() függvény befejezi a munkáját, és a program tick váró üzemmódra vált. Egy új ticknél (ami a szimbólum árváltozását jelenti), a start() függvényt megint végre fogják hajtani. Az üzenet, amit a programban kódoltak attól függően fog megjelenni, hogy az új ár meghaladja-e az előre beállított szintet.

Az ‘if-else’ operátorokat egymásba lehet illeszteni. Az egymásba ágyazott operátorok használatának bemutatására vizsgáljuk meg a következő példát. Ez a probléma kicsit bonyolultabb.

A feladat egyértelmű, azért, hogy megoldjuk ezt a problémát kétszer kell ellenőriznünk az aktuális árat:

1. összehasonlítjuk az árat az 1. szinttel, és

2. összehasonlítjuk a 2. szinttel.

A 10. feladat 1. megoldása: 

A szabályok figyelembevételével, a következő megoldási algoritmust készíthetjük:

38. ábra: blokkdiagram az ‘if-else’ i operátorok végrehajtására a twolevel.mq4 programban.

A programot, ami megvalósítja ezt az algoritmust itt tudjuk követni:  (twolevel.mq4):

//-----------------------------------------------------------------------
// twolevel.mq4
// The code should be used for educational purpose onlyl.
//-----------------------------------------------------------------------
int start() // Special function 'start'
 {
 double
 Level_1, // Alert level 1
 Level_2, // Alert level 2
 Price; // Current price
 Level_1=1.2850; // Set level 1
 Level_2=1.2800; // Set level 2
 Price=Bid; // Request price
//-----------------------------------------------------------------------
 if (Price > Level_1) // Check level 1
 {
 Alert("The price is above level 1"); // Message to the trader
 }
//-----------------------------------------------------------------------
 if (Price < Level_2) // Check level 2
 {
 Alert("The price is above level 2"); // Message to the trader
 }
//-----------------------------------------------------------------------
 return; // Exit start()
 }
//-----------------------------------------------------------------------

Könnyű észrevenni, hogy a  twolevel.mq4 program kódja az onelevel.mq4 program kiterjesztett verziója. Ha az előző számításoknak csak egy szintje volt, ebben az új programban nekünk két szintünk van. Mindkét szintet számszerűen meghatároztuk, és a feladat megoldásához a programnak két olyan blokkja van ahol figyeljük az árváltozást: Marad e az árat az előre beállított szintek tartományán belül, vagy ezen a tartományon kívül van?

Megadjuk a programvégrehajtás rövid leírását!

Miután az előző számításokat végrehajtása megtörtént a vezérlést megkapja az első ‘if-else’ operátor:

//----------------------------------------------------------------------------------
 if (Price > Level_1) // Checking the first level
 {
 Alert("The price is above level 1"); // Message to the trader
 }
//----------------------------------------------------------------------------------

Ezen operátor végrehajtásának bármi is lesz a lefolyása (a kereskedő kap-e üzenetet vagy sem), a végrehajtás átkerül a következő ‘if-else’ operátorhoz:

//----------------------------------------------------------------------------------
 if (Price < Level_2) // Checking the second level
 {
 Alert("The price is below level 2"); // Message to the trader
 }
//----------------------------------------------------------------------------------

A két operátor egymást követő végrehajtása mindkét feltételes tesztelésével végződik, ezen operátorok végrehajtása vezet a probléma megoldásához. Bár a program teljesen megoldja a feladatot, ezt a megoldást nem fogadhatjuk el tökéletesnek. Egy nagyon fontos részletet vegyünk észre: A második feltétel vizsgálatát az első blokk eredményére való tekintet nélkül végre fog hajtódni. A második blokk még akkor is végrehajtásra kerül, ha az ár meghaladja az első szintet.

Itt kell megjegyezni, hogy a program írásakor a legfontosabb szempontok egyike az algoritmus optimalizálása. A fenti példák éppen ezt demonstrálják, ezek rövid, gyorsan végrehajtható programok. Általában egy gyakorlatban használt program ezeknél sokkal nagyobb. Ezek több száz változó értékét használhatják, többszörös teszteket végezhetnek, mindegyik végrehajtása bizonyos mennyiségű időt követel. Mindez azzal a kockázattal jár, hogy a start() különleges függvény működésének az időtartama felülmúlhatja a tickek közötti időtartamot. Ez azt jelenti, hogy néhány tick feldolgozás nélkül maradhat. Ez természetesen egy nemkívánatos helyzet, és a programozónak mindent meg kell tennie azért, hogy megakadályozza ezt. A programvégrehajtás idejének csőkkentésére az egyik módszer az algoritmus optimalizálása.

Fontoljuk meg a legújabb példát még egyszer, hogy az mennyire takarékos az erőforrások tekintetében. Például, miért kérdezzük meg, hogy ” az ár a 2. szint alá csökkent?” ha azt az első blokk már érzékelte, hogy az ár az 1. szint fölött van? Világos, hogy ebben az esetben az ár nem lehet az alacsonyabb 2. szintnél, úgyhogy nem szükséges ezt a második blokkban vizsgálni (nem szükséges végrehajtani az operátorokat ebben a blokkban).

A 10 feladat 2. megoldása

A fenti érvelést figyelembe véve, vizsgáljuk meg a következő optimalizált algoritmust:

39. ábra: blokkdiagram az ‘if-else’ operátor végrehajtására a  twoleveloptim.mq4 programban.

Ez összhangban van az előző blokkdiagramban vázolt algoritmussal, azonban redundáns műveleteket nem fogunk végrehajtani a programban. Az előkészítő számítások után a program tesztelni fogja, hogy az ár az előre beállított szint fölött van-e. Ha igen, a program a megfelelő üzenetet mutatja a kereskedőnek és átadja a vezérlést a ”Következő számítás” blokknak és a második feltételt (az ár alacsonyabb-e az előre beállított szintnél?) nem teszteli. Csak ha az árról nem derült ki, hogy a felső szint fölött van (a válasz, No), akkor kerül a vezérlés második blokkba, ahol a szükséges feltételes tesztet végrehajtjuk. Ha az árról kiderül, hogy az alacsonyabb szint alatt van, a megfelelő üzenetet fogja kapni a kereskedő. Ha nem, a vezérlés a további számításokra lép. Nyilvánvaló, ha a program ezzel az algoritmussal összhangban működik, redundáns műveleteket nem hajt végre, és ez az erőforrások jelentős megtakarításával jár.

//-----------------------------------------------------------------------
// twoleveloptim.mq4
// The code should be used for educational purpose only.
//-----------------------------------------------------------------------
int start() // Special function start()
 {
 double
 Level_1, // Alert level 1
 Level_2, // Alert level 2
 Price; // Current price
 Level_1=1.2850; // Set level 1
 Level_2=1.2800; // Set level 2
 Price=Bid; // Request price
//-----------------------------------------------------------------------
 if (Price > Level_1) // Check level 1
 {
 Alert("The price is above level 1");  // Message to the trader
 }
 else
 {
 if (Price < Level_2) // Check level 2
 {
 Alert("The price is above level 2"); // Message to the trader
 }
 }
//-----------------------------------------------------------------------
 return; // Exit start()
 }
//-----------------------------------------------------------------------

//--------------------------------------------------------------------
 
 if (Price > Level_1) // Check level 1
 {
 Alert("The price is above level 1");  // Message to the trader
 }
 else
 {
 if (Price < Level_2) // Check level 2
 {
 Alert("The price is above level 2"); // Message to the trader
 }
 }
//--------------------------------------------------------------------

Az az ‘if-else’ operátor, amiben a második feltételt tesztelik, annak az első ‘if-else’ operátor egy összetevője, amiben az első feltételt tesztelik. Egymásba ágyazott operátorokat a programozói gyakorlatban széles körben használnak. Ez gyakran ésszerű és néhány esetben ez az egyetlen lehetséges megoldás. Az Alert() függvény helyett az igazi programokban más függvényeket vagy operátorokat használhatnak, amelyek különféle hasznos műveleteket hajtanak végre.

Egy összetett kifejezést szintén használhatnak feltételként az ‘if-else’ operátorban.

Ennek a feladatnak a megfogalmazása hasonló a 10 feladathoz. A különbség az, hogy ebben az esetben nem fontos az ármozgás iránya csak az, hogy az előre definiált tartományon belül van-e. A problémafelvetés szerint nekünk csak magát a tényt kell tudnunk: Az ár a tartományon belül vagy kívül van? Most ugyanazt a kódot használhatjuk csak más üzenet szöveggel.

Itt is, mint az előző megoldásokban ellenőrizni kell az árstátuszt a felső és az alsó szintre vonatkozóan. A 38. ábrán szereplő megoldás algoritmust elvetettük, mert az nem hatékony. A fenti érvelés alapján javasoljuk a következő megoldást:

40. ábra. 11. feladat egyik megoldásának a blokkdiagramja.

Azonban nem szükséges ezt az algoritmust használni. A diagram megmutatja, hogy az algoritmus a programban különböző pontoknál utal ugyanannak az üzenetnek a használatára. A programsorokat ismételni fogjuk, annak ellenére, hogy a végrehajtásuk ugyanazokat az üzeneteket fogja eredményezni. Ebben az esetben sokkal hatékonyabb volna használni az egyetlent ‘if-else’ operátor egy összetett feltétellel:

41. ábra: blokkdiagram az ‘if-else’ operátor végrehajtására a  compoundcondition.mq4 programban.

Annak a programnak a kódja, ami megvalósítja ezt az algoritmust, a következő  (compoundcondition.mq4):

//---------------------------------------------------------------------------------
// compoundcondition.mq4
// The code should be used for educational purpose only.
//---------------------------------------------------------------------------------
int start() // Special function 'start'
 {
 double
 Level_1, // Alert level 1
 Level_2, // Alert level 2
 Price; // Current price
 Level_1=1.2850; // Set level 1
 Level_2=1.2800; // Set level 2
 Price=Bid; // Request price
//--------------------------------------------------------------------------------
 if (Price>Level_1 || Price<Level_2) // Test the complex condition
 {
 Alert("The price is outside the preset range");// Message 
 }
//--------------------------------------------------------------------------------
 return; // Exit start()
 }
//--------------------------------------------------------------------------------

Ez a programmegoldás betekintést enged az összetett feltételek használatába az ‘if-else’ operátorban:

if (Price>Level_1 || Price<Level_2) // Test the complex condition
 {
 Alert("The price is outside the preset range");// Message 
 }

Egyszerűen megfogalmazva, ez a feltétel következő: Ha a Price változó értéke magasabb, mint a Level_1változó, vagya Price változó értéke alacsonyabb, mint a Level_2 változó, a programnak végre kell hajtania az ‘if-else’ operátor törzsét. Megengedett a logikai műveletek használata (&&,|| and !) az ‘if-else’ operátor feltételei meghatározásakor, ezeket széles körben használják a programozói gyakorlatban (lásd Boolean (Logikai) műveletek).

A problémamegoldás során lehet, hogy neked még összetettebb feltételeket is lérte kell hoznod. Néhány kifejezést, köztük az egymásba ágyazottakat is, zárójelbe tehetünk. Például  feltételként használhatod a következő kifejezést az ‘if-else ’ operátorban:

 if ( A>B && (B<=C || (N!=K && F>B+3)) ) // Example of a complex condition

Tehát az MQL4 sok lehetőséget nyújt az ‘if-else’ operátorok használatára: be tudjuk illeszteni őket, egymásba ágyazott szerkezeteket tudunk szerkeszteni, egyszerű és összetett tesztfeltételeket tudunk használni, melyek azt a lehetőséget biztosítják, hogy bonyolult algoritmusokat alkossunk a programjainkban.