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   Programozás MQL4-ben    Programvégrehajtás


Programvégrehajtás

 

A programozási képesség gyorsabban fejleszthető, ha a programozónak már van egy kicsi működő programja. Hogy megértse az egész programot, alaposan meg kell vizsgálnia az összetevői és lépésről lépésre nyomon kell követnie a műveleteket. Jegyezzük meg: a különböző alkalmazási programok különleges függvényeinek tulajdonságai (Expert Advisorok, scriptek, indikátorok) különbözőek. Most elemezni fogjuk, hogy egy Expert Advisor hogyan működik.

Példa egy egyszerű Expert Advisorra:  (simple.mq4)
//--------------------------------------------------------------------
// simple.mq4
// To be used as an example in MQL4 book.
//--------------------------------------------------------------------
int Count=0; // Global variable
//--------------------------------------------------------------------
int init() // Spec. funct. init()
{
Alert ("Function init() triggered at start");// Alert
return; // Exit init()
}
//--------------------------------------------------------------------
int start() // Spec. funct. start()
{
double Price = Bid; // Local variable
Count++; // Tick counter
Alert("New tick ",Count," Price = ",Price);// Alert
return; // Exit start()
}
//--------------------------------------------------------------------
int deinit() // Spec. funct. deinit()
{
Alert ("Function deinit() triggered at deinitialization"); // Alert
return; // Exit deinit()
}
//--------------------------------------------------------------------

A programvégrehajtás szabályaival összhangban (lásd: Programszerkezet és Különleges függvényekez az Expert Advisor következő utat fogja követni:

1. Amikor egy programot csatolnak egy charthoz, az ügyfélterminál a vezérlést átadja a programnak és a program végrehajtása elindul. A programvégrehajtás a fejrésszel indul. A fejrész csak egy sort tartalmaz:

int Count=0; // Global variable

Ebben a sorban a Count globális változót deklaráljuk és inicializáljuk, értéke nulla. (A helyi és globális változókat elemezni fogjuk  A változók típusai részben). Ennek a változónak a deklarációját itt kell elhelyezni, mert ez az algoritmus, amit ebben a bizonyos programban használunk, igényli a Count változót.  Azért kell globális változónak lennie és azért nem deklarálhatjuk egy függvényen belül, hogy a Count változó, globális változóként bármelyik programrészből (bármelyik függvényből) elérhető legyen.

2. A fejrész végrehajtása után az init() különleges függvény végrehajtása  kezdődik. Jegyezzük meg, ennek a függvénynek a hívását nem tartalmazza a programkód. Az init() végrehajtása akkor  kezdődik,  amikor az EA-t hozzácsatolják  egy charthoz. Az ügyfélterminál hívni fogja és végrehajtja az init() függvényt, mert a programkód tartalmazza az init() függvényleírását. Az elemzett programban az init() különleges függvény leírása a következő:

int init() // Spec. funct. init()
{
Alert ("Function init() triggered at start");// Alert
return; // Exit init()
}

A függvénytörzs csak két operátort tartalmaz.

2.1 Az Alert() függvény egy riasztási ablakot nyit:

Function init() triggered at start

2.2 A return operátor befejezi az init() különleges függvény működését.

Az init() függvény végrehajtásnak eredményeképpen egy riasztási ablak nyílik. Valójában egy ilyen algoritmus használata a programokban nagyon ritka, mert az  init() ilyen használata  kevés információt nyújt. Nincs értelme annak, hogy egy függvény tájékoztassa a kereskedőt arról, hogy őt végrehajtották. Itt az algoritmust csak az init() végrehajtásának megjelenítésére használjuk. Figyelem: az init() különleges függvényt csak egyszer hajtják végre egy programban. A függvény végrehajtás a programoperáció kezdetén zajlik, a fejrész feldolgozása után. Amikor a return operátort végrehajtják az init() különleges függvényben az a programvezérlést visszaküldi az ügyfélterminálnak.

3. Az ügyfélterminál észlelte a start() különleges függvény leírását a programban:

int start() // Special funct. start()
{
double Price = Bid; // Local variable
Count++;
Alert("New tick ",Count," Price = ",Price);// Alert
return; // Exit start()
}

31. A vezérlés az ügyfélterminálnál van. Az ügyfélterminál egy új tickre vár és nem indítja el programfüggvényeket addig amíg egy tick nem jön. Ezen idő alatt a program nem működik, semmilyen műveletet nem hajt végre. Egy szünet keletkezik, bár semmilyen közvetlen vagy közvetett utasítás sincs a szünet tartására. Az új tickre való várakozás a start() függvény egyedi tulajdonsága és programozással nem lehet ezen a tulajdonságon változtatni (például kikapcsolni). A program várni fog a vezérlésre addig amíg egy új tick jön. Amikor egy új tick jön, az ügyfélterminál átadja az vezérlést programnak, mégpedig a start() különleges függvénynek. Végül a start() függvény végrehajtása elkezdődik.

32 (1). Az alábbi sorban

 double Price = Bid; // Local variable

a következő műveleteket végezzük:

32.1(1). A Price helyi változó deklarálása (lásd: A változók típusai) Ennek a helyi változónak az értéke elérhető lesz a start() különleges függvény bármelyik részéről.(De csak onnan!).

32.2(1). Az értékadó operátor végrehajtása. Az aktuális ár értékét ki fogják jelölni a Price változónak. Az új ár értéke minden alkalommal megjelenik, amikor egy új tick jön (például az első ticknél az ár egyenlő lehet 1.2744-gyel).

33(1). Ezután a következő sort is végrehajtják:

 Count++;

Ez  a szokásos Count= Count+1 rekord analógja;

Abban a pillanatban, amikor a vezérlés ehhez a sorhoz ér a Count változó érték egyenlő nullával. A Count++ végrehajtásának eredményeképpen, a Count értéke eggyel növekedni fog. Amikor a vezérlés a következő sorra lép a Count érték egyenlő lesz 1-gyel.

34(1). A következő sor Alert() függvényhívást tartalmaz:

 Alert ("New tick ",Count," Price = ",Price);// Alert

A függvény ki fog írni minden állandót és változót, amit a zárójelben felsoroltunk.

A start() függvény első végrehajtásakor először a New tick szöveget írja ki, majd Count változó értékét (első végrehajtásnál ez az érték 1) , ezután a  Price= szöveget és végül a Price változó értékét (a példánkban  ez 1.2744) .

Végül a következő sort láthatjuk:

New tick 1 Price = 1.2744

35(1). operátor

 return; // Exit start()

befejezi a start()  különleges függvény munkáját.

36. A vezérlés vissza tér az ügyfélterminálhoz (amíg egy új tick nem jön).

Az Expert Advisor végrehajtása a start() függvényben történik. Amikor a végrehajtásnak vége van, a start() különleges függvény  a vezérlést visszaküldi az ügyfélterminálnak, és amikor egy új tick jön, az ügyfélterminál újból elindítja a függvényt. Ez a folyamat (a start() függvény végrehajtása és a vezérlés visszaadása  az ügyfélterminálnak) sokáig folytatódhat – akár  napokig vagy hetekig. Ez alatt az idő alatt a start() különleges függvény újra és újra végrehajtódik. A környezeti paraméterektől függően (új árak, kereskedelmi feltételek, az idő, stb.) a start() különleges függvény különböző  műveleteket, megbízások nyitását, zárását  vagy módosítását  hajthat végre.

37. Egy új tick érkezésekor, a 32-36 pontok ismétlődnek. Azonban csak az operátorok végrehajtása ismétlődik, a változók minden alkalommal új értékeket kapnak. Nézzünk meg a start()  függvény első és második végrehajtása közti különbségeket.

32 (2). Ebben a sorban: 

 double Price = Bid; // Local variable

a következő események történnek:

32.1(2). A Price helyi változó deklarációja (változatlan).

32.2(2). Az értékadó operátor végrehajtása. Az aktuális ár értékét fogja kapni a változó (az ár értéke minden alkalommal frissül amikor egy új tick érkezik, például a második ticknél az ár 1.2745) (változik).

33(2). A következő sor végrehajtása:

 Count++;

Ezt sort a Count változó megelőző értéke határozza meg (a start() függvény első végrehajtása után a Count értéke egyenlő 1-gyel, Count++ ismételt végrehajtása eredményeképpen, értékét ismét növelni fogjuk eggyel. Így a második végrehajtásnál Count egyenlő lesz 2-vel (változott).

34(2). Alert() függvény:

 Alert ("New tick",Count," Price = ",Price);// Alert

minden állandót és változót (azok új értékeik) felsorol a zárójelben.

A start() második végrehajtásnál a program a New tick szöveget irja ki, majd a Count változó értékét (második végrehajtásban ez egyenlő 2-vel) ezután a  Price = szöveget és végül a  Price változó  értékét (a példánkban 1.2745) (változott).

Végül a következő sort láthatjuk a riasztási ablakban:

New tick 2 Price = 1.2745

35(2). A következő operátor:

 return; // Exit из start()

befejezi a start() működését  (nincs változás).

36(2). A vezérlést visszaküldi az ügyfélterminálnak, hogy várjon egy új tickre.

37(2). , Azután ez megint ismétlődik. A start() harmadik végrehajtásánál a változók ismét új értékeket fognak kapni és az Alert() függvény ismét  ki fogja írni azokat, megismétlődik a  32-36(3) pont. Azután újra és újra: 32 - 36 (4), 32 - 36 (5),..(6)..(7)..(8)... ha a felhasználó nem avatkozik be, ez a folyamat vég nélkül ismétlődik. Ebben a programban a start() működésének eredményeképpen  látni fogjuk az ár történelmi változását.

A következő események csak akkor fognak megtörténni, amikor egy felhasználó úgy dönt, hogy befejezi a programot és erőszakosan kézzel lekapcsolja a programot egy chartról.

4. Ügyfélterminál a vezérlést átadja a deinit() különleges függvénynek  (a tulajdonságaival összhangban).

int deinit() // Special funct. deinit()
{
Alert ("Function deinit() triggered at exit"); // Alert
return; // Exit deinit()
}

Csak két operátor van a függvény törzsben.

41. Az Alert() ki fogja írni:

Function deinit() triggered at deinitialization

42. A return operátor befejezi a deinit()  működését.

A deinit() függvényt csak egyszer indítja el az ügyfélterminál, azután a szöveg az Alert() ablakban meg fog jelenni és a programot el fogja távolítani a chartról.

5. Itt az Expert Advisor végrehajtásának a története véget ér.

 

Erősítsd hozzá ezt a mintaprogramot bármilyen charthoz és indítsd azt el. A működő program mutatni fog egy Alert()  ablakot, ami tartalmaz minden eseményt, amit létrehozott a függvény.  A figyelmeztető jelzéseket nem nehéz megérteni, és azt sem, hogy ezek a figyelmeztetések melyik különleges függvénytől származnak.


35. ábra. A program működésének az eredménye  simple.mq4.


Ebből a példából láthatod, hogy egy programot a különleges függvények azon tulajdonságaival összhangban hajtanak végre, amiket leírtunk a Különleges függvények bekezdésben. Zárd be a programot és indítsd el azt megint. Miközben ezt többször megteszed, tapasztalatot fogsz szerezni az első programoddal kapcsolatban. Ez működni fog most és a legközelebbi alkalommal is. További programokat tudsz írni magadnak, a leírt szerkezettel összhangban, és egy charthoz csatolva futtatni is tudod őket.

Próbálj megérteni minden fogalmat és szabályt, és az MQL4 programok létrehozása könnyű és kellemes lesz.