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.

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)

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

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

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)
//----------------------------------------------------------------------------------

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:

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.

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:

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.