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   Az MQL4 alapjai  Operátorok


Operátorok

 

Az operátor fogalma

 

Minden programnyelv fő témái közül az egyik az operátor fogalma. A kódolás lehetetlen feladat azon személy számára, aki  nem tanulta meg teljesen ezt az fogalmat. Azonban miután egy programozó alaposan elsajátította az operátorokkal kapcsolatos ismereteket, már nincs messze attól, hogy saját programokat írjon.

Az operátor a program része; egy olyan frázis algoritmikus nyelven, ami előírja az adat átalakítás módszerét.

Minden program tartalmaz operátorokat. Az operátor legközelibb analógiája egy mondat. Ahogy a közönséges mondatok alkotják egy történet vagy egy regény szövegét, úgy az operátorok alkotják a programot.

 

Az operátorok tulajdonságai

 

Az operátoroknak kétfajta tulajdonsága van: a közös tulajdonság és az egyes operátorok speciális tulajdonságai.

Az operátorok közös tulajdonsága

 

Minden operátornak egy közös tulajdonsága van az, hogy őket mind végrehajtják.

Azt mondhatjuk, hogy az operátor egy utasítás, ami az útmutatót tartalmazza  egy művelet végrehajtásához (egy parancs leírása). Egy számítógép, miközben futtatja a programot (folyamatosan feldolgozza az operátorokat, egyiket a másik után) végrehajtja a parancsokat (receptek, utasítások) amiket az operátorok előírnak.

Operátor, mint ilyen csak egy rekord, egy karaktercsoport. Az operátorra semmi nincs befolyással a program alatt. Ezért, amikor egy számítógép végrehajt egy programot, semmi nem történik az operátorokkal, továbbra is maradnak a programban, ahogy a programozó azt megírta. Ha a PC-d végrehajtotta az adatokkal azokat a műveleteket, amelyeket az operátor tartalmaz, azt mondjuk: az operátort végrehajtották.

Az operátorok speciális tulajdonságai

 

Több fajta operátor van. Mindegyik operátornak vannak speciális tulajdonságai. Például egy értékadó operátornak megvan az a képessége, hogy egy bizonyos értéket jelöljön ki az adott változónak; egy ciklus operátor tulajdonsága a többszörös végrehajtás, stb. Az operátorok speciális tulajdonságait részletesen tárgyaljuk a könyv Operátorok  című fejezetében. Itt csak arra hívjuk fel figyelmet, hogy minden operátor típusnak vannak sajátos tulajdonságai, amik csak az adott típusra jellemzőek és nem találhatók meg semmilyen másik operátorban.

Az operátorok típusai

 
Két fajta operátor van: egyszerű operátorok és összetettek.
 

Egyszerű operátorok

 

Az egyszerű operátorok az MQL4ben a ";" (pontosvessző) karakterrel érnek véget. Ezen elválasztót használva, a PC érzékeli, hogy egy operátor hol ér véget és egy másik hol kezdődik. Ez a karakter (a pontosvessző) olyan szerepet tölt be a  egy programban, mint a . (pont) a különálló mondatok között egy normális szövegben. Egy operátor több sorban is elhelyezkedhet. Több operátor is lehet egy sorban.

Minden egyszerű operátor ";” (pontosvessző) karakterrel ér véget.

Példák egyszerű operátorokra:

 Day_Next= TimeDayOfWeek(Mas_Big[n][0]+60); // Egyszerű operátor

Go_My_Function_ind(); // Egyszerű operátor

a=3; b=a*x+n; i++; // Tőbb operátor egy sorban

Print(" Day= ",TimeDay(Mas_Big[s][0]), // Egy operátor..
" Hour=",TimeHour(Mas_Big[s][0]), // több..
" Minute=",TimeMinute(Mas_Big[s][0]),// sorban ..
" Mas_Big[s][0]= ",Mas_Big[s][0], // helyezkedik ....
" Mas_Big[s][1]= ",Mas_Big[s][1]); // el

Összetett operátorok (compoundok)

 

Egy összetett operátor több ";" által elválasztott operátorból áll és kapcsos zárójelek közé van zárva. Az egyszerűség kedvéért,  több operátornak egy operátorként történő használata esetén , a programozók használják az összetett operátorokat (hívják még blokknak vagy blokk kódnak). Az összetett operátorok listáját kapcsos zárójelek határolják. Egy záró kapcsos zárójel jelöli egy összetett operátor végét
Egy példa a feltételes operátorban levő compound használatára. Ez az if operátor egy feltétellel  kezdődik, amit egy compound operátor követ. Az összetett operátor tartalmazza a végrehajtandó operátorok listáját.


17. ábra. Összetett (compound) operátor.

Egy összetett operátor testét kapcsos zárójelek határolják. Minden összetett operátor egy záró kapcsos zárójellel ér véget.

Példák összetett operátorokra:

 // Példa a switch operátorra
switch(ii) // Switch operátor
{ // Nyitó kapcsos zárójel
case 1: Buf_1[Pok-f+i]= Prognoz; break; // Beágyazott operátor (operátor test)
case 2: Buf_2[Pok-f+i]= Prognoz; break; // Beágyazott operátor (operátor test)
case 3: Buf_3[Pok-f+i]= Prognoz; break; // Beágyazott operátor (operátor test)
} // Záró kapcsos zárójel ...
// .. jelzi a compaund operátor végét
//-----------------------------------------------------------------------------------------
// Példa a loop (hurok) használatára
for (tt=1; tt<=Kol_Point[7]; tt++) // A for operátor
{ // Nyitó kapcsos zárójel
Numb = Numb + Y_raz[tt]*X_raz[ii][tt]; // Beágyazott operátor (operátor test)
} // Záró kapcsos zárójel ...
// .. jelzi a compaund operátor végét
//-----------------------------------------------------------------------------------------

// Példa az if feltételes operátorra
if (TimeDay(Mas_Big[f][0])!= 6) // if )
{ // Nyitó kapcsos zárójel
Sred =(Nabor_Koef[ii][vv][2]+ NBh)*Point;// Beágyazott operátor (operátor test)
Ind = Nabor_Koef[ii][vv][0] + f; // Beágyazott operátor (operátor test)
Print(" Ind= ",Ind); // Beágyazott operátor (operátor test)
} // Záró kapcsos zárójel ...
// .. jelzi a compaund operátor végét

Egy compound testét mindig kapcsos zárójelek határolják és nulla, egy vagy több operátorból állhat.

Példák egyszerű operátorokra:

//----------------------------------------------------------------------------------
// Példa a for operátorra
for (n=1; n<=Numb; n++) // for
Mas[n]= Const_1+ n*Pi; // Beágyazott operátor (operátor test)
//----------------------------------------------------------------------------------
// Példa az if feltételes operátorra
if (Table > Chair) // if
Norma = true; // első operátor (suboperator 1)
else // Máskülönben
Norma = false; // második operátor (suboperator 2)
//----------------------------------------------------------------------------------

Több egyszerű operátort lehet kombinálni egy összetett operátorban minden további feltétel nélkül.

Ez egy ritka, de teljesen elfogadható szerkezet. Ebben az esetben az operátorokat, amelyeket kapcsos zárójelek közé zártak operátor blokknak nevezzük. Ez a gyakorlat teljesen elfogadható. A programozó döntheti el, hogy kapcsos zárójelek közé csoportosítsa-e az operátorokat, a kényelmes kódábrázolás kedvéért ez egy jó megoldás. Egy példa az operátorok blokkjára:

 { // Nyitó kapcsos zárójel
Day_Next= TimeDayOfWeek(Mas_Big[n][0]+60); // Egyszerű operátor
b=a*x+n; // Egyszerű operátor
}
// Záró kapcsos zárójel..

Az operátorokkal kapcsolatos követelmények

 

Az operátorokat egy program szövegében a formátum szabályok szerint kell írni (ahogy őket a kódban ábrázolni kell). Az operátor nem szegheti meg ezeket a szabályokat. Ha a program olyan operátort tartalmaz, amit a formátumszabályok megsértésével írtak, a MetaEditor egy hibaüzenetet fog adni. Ez azt jelenti, hogy a programot, ami hibás operátort tartalmaz nem használhatjuk.

Neked ismerned kell az adott fajta operátorok formátumának "operator format" tipikus szabályait. Mindegyik fajta operátornak saját formátuma van. Az operátor formátumok részletes szabályai ennek a könyvnek az Operátorok című fejezetében olvashatók.

 

Az operátorok végrehajtási rendje

 

Minden program egy nagyon fontos jellemzője az operátorok végrehajtásának a sorrendje. Az operátorokat nem lehet végrehajtani ok nélkül vagy szabálytalan sorrendben. Az MQL4 az operátorok végrehajtását következő rendben fogadja el:

Az operátorokat olyan sorrendben hajtják végre, ahogy elhelyezkednek a programban. Az operátorok végrehajtási iránya fentről lefelé és balról jobbra történik.

Ez azt jelenti, hogy az egyszerű és az összetett operátorokat is egyesével hajtják végre (mint a versekben lévő sorokat: először elolvassuk a legfelső sort, azután az alatta lévőt, azután a következő és így tovább). Ha egy sorban több operátor van, őket egymás után kell végre hajtani, balról jobbra, azután pedig át kell térni a következő sorra.

A compound operátorokat, ugyanígy hajtjuk végre, a blokkban lévő operátorokat csak akkor lehet végrehajtani, ha már az előtte lévő operátorokat végrehajtottuk.

Az operátorok írása és végrehajtása: példák

 

Az a programszöveg, amely operátorokat tartalmaz, nem sokban tér el egy normális szövegtől vagy egy matematikai jelrendszertől. Mindazonáltal ez a hasonlóság csak formális. Egy normális szöveg megengedi, hogy a lejegyzését tetszőleges sorrendbe tegyék, míg neked a programban tartanod kell egy egyértelmű rendet.

Példaként lássuk, hogy egy értékadó operátor hogyan működik. Meg fogunk oldani egy egyszerű elsőfokú egyenletrendszert és össze fogjuk hasonlítani néhány matematikai számítás ábrázolását egy normális szövegben és egy programkódban.

7. feladat: Nekünk van egy egyenletrendszerünk:
Y = 5
Y - X = 2
Az X változó számszerű értékét kell meg találni.

1.  megoldás: A normális szöveg egy papírlapon:

1.  5 - Х = 2

2.  Х = 5 - 2

3.  Х = 3

2. megoldás: a program szövege:

Y = 5; // 1. sor
X = Y - 2; // 2. sor

Az első és a második megoldásban is a feljegyzéseknek (sorok) van egy befejezett tartalma. Mindazonáltal az 1. megoldás sorait nem használhatjuk egy programban ebben a formában, mert a megjelenésük nem felel meg az értékadó operátor formátumának.

Az 1. megoldás a papíralapú feljegyzés néhány függőséget képvisel. Ezt csak arra tudjuk használni, hogy a változók közti kapcsolatokról tájékoztassák a programozót. Az operátoroknak egy programban más a célja - tájékoztatni a gépet milyen műveletek vannak és ezeket milyen sorrendben kell végre hajtania. Kivételek nélkül minden operátornak olyan pontos utasításokat kell adni, amelyek nem engednek meg kétértelműséget.

A 2. példában mindkét operátor értékadó operátor. Minden értékadó operátor a gépnek szó szerint a következő utasítást adja:

Számítsd ki a kifejezés értékét az egyenlőségjel jobb oldalán és rendeld hozzá ezt az értéket az egyenlőségjel bal oldalán levő változóhoz.

Ez okból, egy értékadó operátorban az egyenlőségjel bal oldalán csakis a változó és semmi más nem lehet. Például, az 5- Х = 2 rekord használata hibát tartalmaz, mert az 5 - Х karakter csoport nem egy változó. Ezért nincs memóriacella kijelölve, ahová az egyenlőségjel jobb oldalán szereplő kifejezés számszerű értékét el lehetne helyezni.

Kövessük a számítógépet a második megoldás végrehajtása alatt!

1. Lépés az operátorra (1. sor).

Y = 5;  // 1. sor

2. Tájékozódik, hogy mi van az operátor jobb oldalán (a jobb oldali rész az egyenlőségjel és a pontosvessző között helyezkedik el).

3. A számítógép érzékelte, hogy az operátor jobb oldali része egy számszerű értéket tartalmaz.

4. Felveszi ezt a számszerű érték (5) az Y változó memóriacellájában.

5. A következő operátorra lép (2. sor).

X = Y - 2;  // Line 2

6. Megvizsgálja az operátor jobb oldalát.

7. A számítógép érzékelte, hogy az operátor jobb oldala egy kifejezést  tartalmaz.

8. Kiszámolja az operátor jobb oldalának a számszerű értékét (5 - 2).

9. Ezt a számszerű értéket (3) rögzíti az Х változó memóriacellájában.

Az 1-4 lépésekben a számítógép az első operátort hajtja végre (1. sor). A számítógép az 5-9 lépések a második operátort hajtja végre (2. sor).

Azért hogy egy működőképes programot kódoljon, a programozónak tisztában kell lennie azzal, hogy hogyan fogják végrehajtani a műveleteket ebben a programban. Nem minden matematikai számítást lehet részletesen egy programba beletenni, néha szükség van az operátorok előkészítésére.

Például sok közbenső számítást végeznek a matematikai feladatok megoldása során. Segíthet egy matematikus, hogy megtaláljon egy megfelelő megoldást, de kiderülhet, hogy ez haszontalan a programozás szempontjából. Csak értelmes feladatokat bízzunk a programra: adjuk meg a változók eredeti értékeit és a képletet a másik változó értékének kiszámításához. Az előző példában az első operátor az Y változó számszerű értékével kapcsolatos információt képviseli, és a második operátor nyújtja a képletet, hogy hogyan számítsa ki az X változó értékét, ami iránt érdeklődünk.

Minden működőképes program a kifejezések ismerős látványát tartalmazza. Ha ilyen kifejezéseket találsz, el tudod dönteni, hogy lehetséges-e, hogy ezek a kifejezések operátorokban szerepeljenek a programodban. Például, a lenti rekord:

X = X + 1; // Ez egy számláló

Úgy tűnik, hogy hibás a matematikai logika és józan ész szempontjából. Mindazonáltal, ez elfogadható, ha operátorként vizsgálod (mellesleg ezt az operátort széles körben használják a kódolásban).

Ebben az operátorban kiszámítjuk az X változó egy új értékét. Mikor végrehajtjuk az értékadó operátort, (vagyis kiszámoljuk az operátor jobb oldalának az értékét), a számítógép érzékeli azt, hogy egy memóriacella tartalmazza X változó számszerű értékét, (például kiderül, hogy ez pillanatnyilag egyenlő 3-mal), kiszámítja a kifejezést az operátor jobb oldalán (3 + 1), és a kapott új értéket (4) írja X változó részére fenntartott memóriacellába. Az értékadó operátor végrehajtása azt eredményezi, hogy az X változó új értéket kap (4). A gép tárolni fogja X változó ezen értékét, addig, amíg egy másik értékadó operátor meg nem változtatja azt. Ebben az esetben ennek a változónak a kiszámított az új értéke lesz tárolva a következő változásig.