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   Változók    Tömbök


Tömbök

 

Annak az információnak a nagy részét, amit az alkalmazási programok használnak tömbök tartalmazzák.

A tömbök fogalma

 

Tömb az azonos típusú változók rendezett érték készletének az összefoglaló neve. A tömbök egy dimenziósak és többdimenziósak lehetnek. Egy tömbben levő dimenziók maximális száma négy lehet. Bármilyen adattípust elhelyezhetünk tömbökben.

A tömbelem egy tömb része; egy indexelt változó, aminek van neve és valamilyen érték.


59. ábra. Az egész számtípus tömbjeinek a grafikus bemutatása: a) egy dimenziós; b) kétdimenziós; c) háromdimenziós.

Indexelés

 

A tömbelem-index egy vagy több egész értékű állandó, változó vagy kifejezés felsorolása vesszővel elválasztva és szögletes zárójelbe zárva. A tömbelem-index egyértelműen meghatározza egy tömb valamely elemének a helyét. A tömbelem-indexet egy változó (tömbnév) után helyezzük el és a tömbelem integrál részét képzi. Az MQL4-ben az indexelés nullával kezdődik.

Az olyan indexelés is elfogadható, amikor mindegyik index külön zárójelben van:

Egy kétdimenziós tömb mindennapos analógja egy moziterem. A sor száma az első index értéke, és a soron belül levő ülőhely száma a második index, a nézők a tömbelemek, a néző vezetékneve a tömbelem értéke, a mozijegy (a sor és ülőhely meghatározása) egy módszer, amivel hozzáférünk egy tömbelem értékéhez.

Tömbdeklaráció és hozzáférés a tömbelemekhez

 

Mielőtt használ egy tömböt egy programban, azt deklarálni kell. Egy tömböt ugyanúgy, mint egy változót deklarálhatunk globális és helyi szinten. Mint az várható volt, a globális tömbelemek értékei elérhetőek az egész programból, a helyi tömbelemek értékei csak abból a függvényből, amiben deklarálva van. Egy tömböt nem deklarálhatnak az ügyfélterminál szintjén, vagyis az ügyfélterminál globális változóit nem gyűjthetik egy tömbbe. A tömbelemek értéki bármilyen típusúak lehetnek. A tömbelemek értékeinek a típusa az, amit a tömbdeklarációnál megadtak. Amikor deklarálunk egy tömböt meg kell adni a tömb elemeinek típusát, a tömb nevét és a dimenziókban lévő elemek számát:

A tömbelemekhez csak elemenként férhetünk hozzá, vagyis egy adott pillanatban csak egy összetevőhöz férhetünk hozzá. A tömbösszetevők típusát nem adjuk meg a programban. A tömbösszetevő értéket hozzá lehet rendelni vagy meg lehet változtatni az értékadó operátorral:

A tömbelemek értéke az 59. ábrán a következő:

- az egydimenziós tömb Mas[4] elem értéke a 34 egész szám;

- a kétdimenziós tömb  Mas[3,7] elem értéke a 28 egész szám;

- a háromdimenziós tömb Mas[5,4,1] elem értéke a 77 egész szám.

Megjegyzés: a tömbelem-index minimális értéke 0 (nulla) és a legnagyobb értéke egyel kisebb a megfelelő dimenzió elemeinek a számánál, amit a tömbdeklarációnál megadtunk.

Például, a Mas[10][15] tömbben az elem index legkisebb értéke Mas[0,0], és a legnagyobb értéke az  elem indexnek Mas[9,14] .

A tömbökkel szintén végezhetünk műveleteket a beépített függvények használatával. További információt keress a fejlesztő honlapján

 (http://docs.MQL4.comvagy a Meta Editor Helpben. Ezek közül a függvények közül néhányat tovább elemzünk.

Tömb inicializálás

 

Egy tömböt a megfelelő típus állandói által inicializálhatunk. Egydimenziós és többdimenziós tömböket inicializál az állandóknak az egydimenziós sorozata, amiket vesszők választanak el. A sorozatot kapcsos zárójelekbe zárjuk:

int Mas_i[3][4] = { 0, 1, 2, 3, 10, 11, 12, 13, 20, 21, 22, 23 };

double Mas_d[2][3] = { 0.1, 0.2, -0.3, -10.2, 1.5, 7.0 };

bool Mas_b[5] = { false, true, false, true, true }

Az tömb inicializásakor egy vagy több állandót kihagyhatunk. Ez esetben a számszerű típus megfelelő tömbelemeit nulla inicializálja, a string típusú tömbök elemei a "" string érték inicializálja  (idézőjelek tartalom nélkül), egy üres karaktersorozat (nem kell összekeverni egy üres hellyel). A következő program bemutatja a tömbök értékeit, amelyeket néhány érték kihagyásával inicializált egy változó sorozat ( arrayalert.mq4 script ):

//--------------------------------------------------------------------
// arrayalert.mq4
// The code should be used for educational purpose only.
//--------------------------------------------------------------------
int start() // Special funct. start()
{
string Mas_s[4] = {"a","b", ,"d"}; // String array
int Mas_i[6] = { 0,1,2, ,4,5 }; // Integer type array
Alert(Mas_s[0],Mas_s[1],Mas_s[2],Mas_s[3]); // Displaying
Alert(Mas_i[0],Mas_i[1],Mas_i[2],Mas_i[3],Mas_i[4],Mas_i[5]);
return; // Exit start()
}
//--------------------------------------------------------------------

Ha egy egy-dimenziós tömb mérete nincs megadva, azt az inicializáló változó sorozat mérete alapján meghatározza a szerkesztő. Egy tömböt inicializálhat a beépített ArrayInitialize() függvény is. Minden tömb statikus, vagyis statikus típusú még akkor is, ha az inicializálásnál ezt nyíltan nem jelzik. Ez azt jelenti, hogy minden tömb megőrzi az értékeit azon függvények hívásai között is, amelyekben a tömböt deklarálták ( lásd:  A változók típusai).


Minden tömb, amit az MQL4-ben használunk két csoportba osztható: felhasználói tömbök (a programozó által létrehozott) és elöre definiált tömbök (tömbök előre definiált nevekkel és adattípusokkal). A felhasználói tömbök méretei és az elemeik értékei attól függenek, hogy a programot hogyan hozták létre, vagyis a programozótól. A felhasználói tömbelemek értékei a programvégrehajtás ideje alatt rögzítettek és csak a számítások befejezése után tudjuk őket megváltoztatni. Azonban az elöre definiált tömbök elemeinek az értékeit nem változtathatjuk meg, a méretük növekszik, amikor a történelmi adatokat frissíti a terminál.

Felhasználói tömbök


'switch' operátor fejezet 18. feladatában megoldottunk egy példát. Tegyük azt bonyolultabbá (növeljük a pontok számát, és 100-ig írjuk ki szavakban) és gyakoroljuk a tömbök használatát.

25. feladat: Hozzunk létre egy programot, amiben a következő feltételeket valósítjuk meg: ha az ár túllép egy bizonyos szintet, bemutat egy üzenetet, amiben a túllépést jelzi, (100 pontig); egyébként tájékoztat, hogy az ár még nem lépte át ezt a szintet.

A 25. feladat megoldása, ami egy string típusú tömböt használ a következői:  (stringarray.mq4  Expert Advisor ):

//--------------------------------------------------------------------
// stringarray.mq4
// The code should be used for educational purpose only.
//--------------------------------------------------------------------
extern double Level=1.3200;                     // Preset level
string Text[101];                               // Array declaration
//--------------------------------------------------------------------
int init()                                      // Special funct. init()
  {                                             // Assigning values
   Text[1]="one ";             Text[15]="fifteen ";
  
Text[2]="two ";             Text[16]="sixteen ";
  
Text[3]="three ";           Text[17]="seventeen ";
  
Text[4]="four ";            Text[18]="eighteen ";
  
Text[5]="five ";            Text[19]="nineteen ";
  
Text[6]="six ";             Text[20]="twenty ";
  
Text[7]="seven ";           Text[30]="thirty ";
  
Text[8]="eight ";           Text[40]="forty ";
  
Text[9]="nine ";            Text[50]="fifty ";
  
Text[10]="ten ";            Text[60]="sixty";
  
Text[11]="eleven ";         Text[70]="seventy ";
  
Text[12]="twelve ";         Text[80]="eighty ";
  
Text[13]="thirteen ";       Text[90]="ninety";
  
Text[14]="fourteen ";       Text[100]= "hundred";
  
// Calculating values
   for(int i=20; i<=90; i=i+10)                // Cycle for tens
     {
      for(int j=1; j<=9; j++)                  // Cycle for units
         Text[i+j]=Text[i] + Text[j];          // Calculating value  
     }
   return;                                     // Exit init()
  }
//--------------------------------------------------------------------
int start()                                     // Special funct. start()
  {
   int Delta=NormalizeDouble((Bid-Level)/Point,0);// Excess
//--------------------------------------------------------------------
   if (Delta>=0)                                // Price is not higher than level
     {
      Alert("Price below level");               // Alert
      return;                                   // Exit start()
     }
//--------------------------------------------------------------------
   if (Delta<100)                               // Price higher than 100
     {
      Alert("More than hundred points");        // Alert
      return;                                   // Exit start()
     }
//--------------------------------------------------------------------
   Alert("Plus ",Text[Delta],"pt.");            // Displaying
   return;                                      // Exit start()
  }
//--------------------------------------------------------------------

A probléma megoldására a Text[] string tömböt használjuk. A program végrehajtása alatt a tömbelemek értékeit nem változhatnak meg. A tömböt globális szinten deklaráljuk (a különleges függvényeken kívül), a kezdeti tömb előkészítés az init()-ben történik. Így a start() függvényben csak a szükséges számításokat végezzük minden ticknél.

A Text[] tömbelemek értékeit  string állandóként jelöljük ki. A továbbiakban, a ciklusokban kiszámolt értékeket összeadjuk és hozzárendeljük a string sorokat.

 for (int i = 20; i<=90; i=i+10) // Cycle for tens
{
for (int j=1; j<=9; j++) // Cycle for units
Text[i+j] = Text[i] + Text[j]; // Calculating value
}

Ezeket a számításokat könnyen megérthetjük: a 21-99 indexszel rendelkező tömbelemekhez (kivétel a 10 többszöröseinek indexei) a megfelelő string értéket kiszámoljuk. Figyeld az indexeket a következő sorban:

 Text[i+j] = Text[i] + Text[j]; // Calculating value

Indexként változókat (amely értékei megváltoznak a ciklusban) és kifejezéseket használunk. Az  i és j változók értékeitől függően, a program összegezni fogja az értékeket, és ezt az értéket el fogja küldeni a megfelelő Text[] tömbelemekhez,  ahol a kiszámított (i+j) eredménye fogja kijelölni a tömbelem értékét. Például, ha a számítás eredményeként i értéke 30 és j értéke7, azon elemek neve, amelyeket össze kell fűzni a Text[30] és Text[7] tömbelem értéke, ezt az eredményt jelöli ki a Text[37].  Bármilyen másik egész számtípusú változót használhatunk tömbelem indexként. Ebben a példában a  start() függvényben a Delta változót használjuk tömb indexként - Text[Delta].

A start() különleges függvénynek egyszerű kódja van. A Delta értékétől függő számításokat végzünk. Ha ez kisebb vagy egyenlő mint 100 pont, akkor a megfelelő üzenet mutatása után a start() végrehajtás befejeződik. Ha az érték a meghatározott tartományon belül van, a riasztást a problémafelvetés szerint mutatja.


60. ábra. A kívánt értéket mutatja a  stringarray.mq4  EA

Figyelj 18. feladat megoldására. Ha ugyanazt a megoldás használtuk volna a 25. feladat megoldására, a 'switch' operátor körülbelül 100 sort tartalmazna - egy sort mindegyik megoldási variációhoz. A programfejlesztés ilyen megközelítése nem megfelelő. Azonfelül, az olyan megoldások kezelhetetlenek ahol több tíz, több száz vagy több ezer változó értékével kell dolgozni. Ilyen esetben a tömbök használata indokolt és nagyon kényelmes.

Előre  definiált  tömbök

 

Az előre definiált tömb egy tömb előre meghatározott névvel (Open, Close, High, Low, Volume és Time), amely tömbök elemei tartalmazzák a történelmi bárok megfelelő jellemzőinek az értékeit.

Az adatok, amelyeket az előre definiált tömbök tartalmaznak, nagyon fontos információk és az MQL4 programozásban széles körben használjuk őket. Mindegyik előre definiált tömb egy egy dimenziós tömb, és egy bizonyos bar jellemzőiről tartalmaz történelmi adatot. Mindegyik bárt jellemez a nyitó ár Open[], a záró ár Close[], a maximális ár High[], a minimális ár Low[], a mennyiség (a bárban lévő tickek száma) Volume[] és a nyitási idő Time[]. Például az Open[] előre definiált tömb az ablakban lévő bárok nyitási árairól ad információt: az Open[1] tömbelem értéke az első bár nyitó ára, Open[2] a második bár nyitó ára, stb. ugyanúgy igaz ez a többi bár jellemzőre is.

A Zéró bár az aktuális bár, ami még teljesen nem alakult ki. Az ablakban a zéró bár jobbról az utolsó.

Bárok (és megfelelő előre definiált tömbindexek) számolását a null bártól indítjuk. A [0] indexszel rendelkező előre definiált tömb elemek értékei azok az értékek, amelyek a zéró bárt jellemzik. Például Open[0] értéke a zéró bár nyitó ára. 61. ábra mutatja a bárok indexelését és a bárjellemzők összegzését.


61. ábra. Mindegyik bárt az értékek készlete jellemez, amit az arrays-timeseries tartalmaz.
A bárokat a zéró bártól számoljuk.

A 61. ábrán a zéro bárnak a következő jellemzői vannak:

Index
Open[] Close[] High[], Low[], Time[]
[0] 1.2755 1.2752 1.2755 1.2752 2006.11.01 14:34


Egy idő után az aktuális bár kialakul és egy új bár fog meg jelenni az ablakban. Most ez az új bár lesz a zéró bár, és a kialakult teljes bár lesz az első ([1]indexszel):


62. ábra. A bárok egy idő után elmozdulnak, míg a számozás nem mozdul el.

Most az előre definiált tömb elemeinek az  értékei a következők lesznek:

Index
Open[] Close[] High[], Low[], Time[]
[0] 1.2751 1.2748 1.2752 1.2748 2006.11.01 14:35
[1] 1.2755 1.2752 1.2755 1.2752 2006.11.01 14:34

A későbbiekben, az ablakban új bárok fognak megjelenni. A  formálódó, jobbszélső bár sorszáma mindig nulla lesz, az ettől balra lévő lesz az első bár, a következő - az második, stb. A bár tulajdonságait nem változtathatjuk meg: a példában a bárt 14:34-nél nyitották ki, és a nyitási idő mindig 14:34 fog maradni, a többi paraméter szintén változatlan marad. Azonban ennek a bárnak az indexe az új bárok megjelenése után növekedni fog.

Tehát az  előre definiált tömbökkel kapcsolatban a legfontosabb szabály a következő:

Az előre definiált tömb elemek értékei egy bár megfelelő jellemzői és ezek változatlanok (a zéró bár következő jellemzőit kivéve: Close[0], High[0], Low[0], Volume [0]), a bár index aktuális változása visszatükrözi a bár létrejötte óta eltelt  időt.

Tudni kell, hogy a bár nyitási időpontját a percek többszörösével számolják, a másodperceket nem vesznek számításba. Más szóval, ha a 14:34 és 14:35 közötti időszakban egy új tick 14:34:07-nél érkezett, akkor a legnagyobb felbontásnál, a perces idősíkon 14:43-nál fog megjelenni. A 15 perces felbontásban a bár nyitási időpontok a 15 perc többszörösei, egy órán belül az első bárt az óra 00 percében, a másodikat a 15. a harmadikat a 30. és a negyediket a 45. percében nyitja.

előre definiált tömbökben történő indexelés jelentőségének megértéséhez oldjunk meg egy egyszerű feladatot:

26. feladat: Keressük meg a minimális és a maximális árat az utolsó n bárban.

Figyelem, az ilyen problémák megoldása lehetetlen anélkül, hogy az előre definiált tömböket alkalmaznánk. Annak az Expert Advisornak, amely meghatározza az legnagyobb és a legkisebb árat az előre beállított számú utolsó bár között, a következő lehet a megoldása  (extremumprice.mq4):

//--------------------------------------------------------------------
// extremumprice.mq4
// The code should be used for educational purpose only.
//--------------------------------------------------------------------
extern int Quant_Bars=30; // Amount of bars
//--------------------------------------------------------------------
int start() // Special funct. start()
{
int i; // Bar number
double Minimum=Bid, // Minimal price
Maximum=Bid; // Maximal price

for(i=0;i<=Quant_Bars-1;i++) // From zero (!) to..
{ // ..Quant_Bars-1 (!)
if (Low[i]< Minimum) // If < than known
Minimum=Low[i]; // it will be min
if (High[i]> Maximum) // If > than known
Maximum=High[i]; // it will be max
}
Alert("For the last ",Quant_Bars, // Show message
" bars Min= ",Minimum," Max= ",Maximum);
return; // Exit start()
}
//--------------------------------------------------------------------

Az extremumprice.mq4 programban egy egyszerű algoritmust használunk. Az elemezni kívánt bárok számát a Quant_Bars extern változóban adjuk meg. A program elején a vételi árat jelöljük ki a kívánt Minimumnak és Maximumnak. A legnagyobb és legkisebb értékek keresése a ciklusoperátorban történik:

 for(i=0;i<=Quant_Bars-1;i++) // From zero (!) to..
{ // ..Quant_Bars-1 (!)
if (Low[i]< Minimum) // If < than known
Minimum = Low[i]; // it will be min
if (High[i]> Maximum) // If > than known
Maximum = High[i]; // it will be max
}

Itt megadjuk a Low[i] és High[i] előre definiált tömbelemek feldolgozott index érték tartományát (i integer változó). Figyelj az 1. Kifejezésre  és a Feltételre a ciklusoperátor fejlécében:

 for(i=0;i<=Quant_Bars-1;i++) // From zero (!) to..

Az első ismétlést a nulla értékű indexszel végezzük. Ez azt jelenti, hogy az első ismétlésben a zéró bár értékeit elemezzük. Így szavatolt, hogy azokat az utolsó ár-értékeket, amik megjelentek az ablakban, szintén számításba vegyük. Az Előre definiált változók rész tartalmazza azt a szabályt, ami szerint minden előre definiált változó értékét, köztük az előre definiált tömböket is, frissíti a terminál a különleges függvények kezdetekor. Ezért az árértékek változatlanok fognak maradni a számítások alatt.

Az előre definiált tömb indexének felső határa a feldolgozott bárok számánál egyel kisebb. A példánkban a bárok száma 30. Ez azt jelenti, hogy a legnagyobb indexérték 29. Az előre definiált tömb elemek index értékei 0-tól 29-ig terjednek, vagyis 30 bárt fogunk feldolgozni a ciklusban.

Könnyű megérteni a számításokat a ciklusoperátor-törzsben:

 if (Low[i]< Minimum) // If < than known
Minimum = Low[i]; // it will be min
if (High[i]> Maximum) // If > than known
Maximum = High[i]; // it will be max

Ha a Low[i] árfolyamérték (az ismétlés alatt az aktuális indexhez tartozó ár érték) alacsonyabb az eddigi minimális értéknél ez az új érték válik a minimális értékké. Ugyanezzel a módszerrel kiszámoljuk ki a legnagyobb értéket is. A ciklusok végén megkapjuk a Minimum és Maximum változók kívánt értékét. A további programsorokban ezeket az értékeket jelezzük ki.

A program végrehajtásával ezt az eredményt kapjuk:


63. ábra. Az  extremumprice.mq4 EA végrehajtásának eredménye.

Figyeljük meg, hogy az Expert Advisor végtelenül hosszú ideig helyesen működhet, és a program ugyanazokat az index értékeket fogja használni (ebben az esetben 0-tól 29-ig). A null indexszel rendelkező előre definiált tömbelemek értékei változni fognak az új tick megjelenésekor  (kivéve az Open[] és Time[] értékeit, mert azok már nem változhatnak a null báron).

Néhány esetben akkor kell valamilyen műveletet  végrehajtanunk, amikor egy bár teljesen kialakult. Ez például az olyan algoritmusokban fontos, amik a gyertyaelemzésen alapultak. Ilyen esetben csak a teljesen kialakult bárokat vesszük számításba.

27. feladat: Mindegyik bár kezdetén mutassunk egy üzenetet az utolsó n kialakult báron belüli minimális és maximális árról.

A feladat megoldáshoz meg kell határozni egy új bár kezdetét és észlelni kell egy új ticket a nullbáron. Van erre egy egyszerű és megbízható módszer  - figyeljük a nullbár nyitási idejét. A nullbár nyitási ideje az a bárjellemző, ami nem változik a bár kialakulása alatt. Az új tickek, amik egy bár kialakulása alatt jönnek, megváltoztathatják a High[0], Close[0] és Volume[0] értékét. De az Open[0] és Time[0] értékét nem változtathatják meg.

Ezért elég az, hogy figyeljük a null bár nyitási idejét, és mindegyik ticknél azt összehasonlítjuk az utoljára ismert nulla bár nyitási idejével. Ha nem találunk egyezést, az azt fogja jelenteni, hogy egy új bár kezdődött (és az előző befejeződött). A newbar.mq4 EA tartalmazza egy új bár észlelésének az algoritmusát, és azt egy felhasználói függvény alakjában valósítja meg:
//--------------------------------------------------------------------
// newbar.mq4
// The code should be used for educational purpose only.
//--------------------------------------------------------------------
extern int Quant_Bars=15; // Amount of bars
bool New_Bar=false; // Flag of a new bar
//--------------------------------------------------------------------
int start() // Special funct. start()
{
double Minimum, // Minimal price
Maximum; // Maximal price
//--------------------------------------------------------------------
Fun_New_Bar(); // Function call
if (New_Bar==false) // If bar is not new..
return; // ..return
//--------------------------------------------------------------------
int Ind_max =ArrayMaximum(High,Quant_Bars,1);// Bar index of max. price
int Ind_min =ArrayMinimum(Low, Quant_Bars,1);// Bar index of min. price
Maximum=High[Ind_max]; // Desired max. price
Minimum=Low[Ind_min]; // Desired min. price
Alert("For the last ",Quant_Bars, // Show message
" bars Min= ",Minimum," Max= ",Maximum);
return; // Exit start()
}
//--------------------------------------------------------------------
void Fun_New_Bar() // Funct. detecting ..
{ // .. a new bar
static datetime New_Time=0; // Time of the current bar
New_Bar=false; // No new bar
if(New_Time!=Time[0]) // Compare time
{
New_Time=Time[0]; // Now time is so
New_Bar=true; // A new bar detected
}
}
//--------------------------------------------------------------------

A New_Bar globális változót használjuk a programban. Ha az értéke 'true', ez azt jelenti, hogy az utoljára ismert tick egy új bár első tickje. Ha a New_Bar érték 'false' az utoljára ismert tick az aktuális nulla báron belül van, vagyis nem a bár első tickje.

Flag (zászló) egy változó, aminek az értékét valamely esemény vagy tény határozza meg.

Egy programban a flag-ek használata nagyon kényelmes. A flag értékét valahol beállítjuk, és különböző helyekben használhatjuk. Néha olyan algoritmust használunk a programban, amiben egy döntés meghozása különböző flag-ek értékének a kombinációjától függ. A newbar.mq4 

Expert Advisorban a New_Bar változót egy flag-ként használjuk. Az értéke közvetlenül egy új bár képződésének tényétől függ.

Az új bár észlelését jelző számításokat a Fun_New_Bar() felhasználói függvényben helyeztük el. A függvény első sorában a New_Time statikus változót deklaráljuk (emlékezzünk, a statikus változók nem vesztik el az értékeiket, a függvény végrehajtása után). Mindegyik függvényhívásnál a New_Bar globális változó értékét 'false'-ra állítjuk. Egy új bár észlelését 'if' operator végrehajtása végzi:

 if(New_Time != Time[0]) // Compare time
{
New_Time = Time[0]; // Now time is so
New_Bar = true; // A new bar detected
}

Ha New_Time értéke (az előző munkamenetben kiszámolt) nem egyenlő a Time[0]-val, ez jelenti egy új bár képződésének a tényét. Ezesetben a vezérlés lekerül az 'if' operátor testhez, ahol a null bár új nyitási idejét tároljuk és az új értéket kapja a New_Bar változó (azt is mondhatjuk, hogy a zászlót egy emelkedő pozícióba helyeztük).

Miközben ilyen problémákat oldunk meg, fontos számba venni a felhasznált különböző flag-ek sajátosságait. Ebben az esetben a New_Bar sajátossága az, hogy az értéket (flag) még azelőtt kell frissíteni mielőtt az értékét a számításban felhasználnánk (ebben az esetben - a különleges start()függvényben). A New_Bar értékét meghatározó felhasználói függvényt, ezért kell a program elején meghívni, még az első olyan számítás előtt, amiben a New_Bar-t használjuk. A különleges start() függvény felépítése ennek  megfelel: felhasználói függvényhívást közvetlenül a változók deklarációja után hajtjuk végre.

A kívánt értékek számítása csak akkor szükséges, ha a start()-ot  egy olyan tick indítja el, ami egy új bárt kezd. Ezért a start() indítása után azonnal vizsgálja egy új bárképződést, a flag helyzetét (a New_Bar értékét elemzi):

 if (New_Bar == false) // If bar is not new..
return; // ..return

Ha az utolsó tick, ami elindította start() végrehajtását, nem alakít egy új bárt, a vezérlés átkerül egy olyan operátorhoz, ami befejezi a start() végrehajtását. És csak ha egy új bár nyílik, akkor kerül a vezérlés tovább a következő sorra (mit a feladatmegoldás igényel).

A legnagyobb és legkisebb érték számítása közben használtuk az ArrayMaximum() és ArrayMinimum() beépített függvényeket. Mindkét függvény tömbelem-indexet küld vissza (a legnagyobb és legkisebb értéknek megfelelően) egy meghatározott index tartományból. A problémafelvetés szerint csak a teljesen alakult bárokat kell elemezni, ez az oka, hogy a kiválasztott index intervalluma miért 1 és Quant_Bars - a bárok mennyisége (a zéró bár még nem alakult ki és ezért nem vesszük figyelembe a számítások alatt). Az előre definiált tömbök függvényeivel kapcsolatos további információt találunk a fejlesztő honlapján (http://docs.MQL4.com) vagy a MetaEditor Helpben.

A 64. ábrán láthatjuk a programvégrehajtás alatt, az előre beállított időintervallumban lévő legnagyobb és legkisebb árak változását:


64. ábra. A  newbar.mq4 Expert Advisor végrehajtásának eredmény.