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   Operátorok     'continue'  operátor


A 'continue' operátor


Néha, egy ciklus alkalmazásakor szükség lehet az aktuális ismétlés (iteráció) idő előtti befejezésére, és a következő ismétlésre lépésre anélkül, hogy végrehajtanánk a ciklustestben fennmaradó operátorokat. Ilyen esetekben  a ‘continue’ operátort kell használnunk.

A ‘continue’ operátor formátuma  

Az ‘continue’ operátor egy szóból és a végén ";” -ből (pontosvessző) áll.

 continue;   // 'continue' operátor

A ‘continue’ operátor végrehajtási szabályai  


A ‘continue’ operátor leállítja a legközelebbi 'while' vagy 'for' ciklusoperátor aktuális ismétlésének a végrehajtását. A ‘continue' operátor végrehajtása azt eredményezi, hogy a program a legközelebbi 'while' vagy 'for' ciklusoperátor következő ismétlésére lép. A ‘continue’ operátort csak a fenti ciklusoperátorok testében tudjuk használni.


Gondolkozzunk, a ‘continue’ operátort hogyan tudnánk a gyakorlatban használni.

16. feladat: Az első farmon van 1000 juh. Ezen a farmon a juhok napi 1 százalékot szaporodnak. Ha a juhok száma a hónap végén meghaladja az 50 000-et, akkor a juhok 10 százalékát át kell helyezni egy másik farmra. A második farmon a juhok száma mikor fogja a 35 000-et elérni? (Legyen minden hónapban 30 nap.)

A problémamegoldás algoritmusa nyilvánvaló: Szerveznünk kellene egy olyan ciklust, ahol a program az első farmon lévő juhok mennyiségét számolja. A problémafelvetés szerint a juhokat a hónap végén áthelyezik a második farmra. Ez azt jelenti, hogy nekünk  létre kell hoznunk egy további (belső) ciklust, ahol az aktuális hónapban a juhok gyarapodását számoljuk. A hónap végén meg kell állapítanunk, hogy 50 000 juhos határát átléptük-e, vagy sem. Ha igen, nekünk ki kell számolnunk, hogy valamennyi juhot fogunk áthelyezni a második farmra a hónap végén, és ezekkel a juhokkal a második farmon gazdálkodunk.

A felvázolt algoritmust a sheep.mq4. scriptben valósítjuk meg .  A ‘continue’ operátor itt arra használjuk, hogy a külső ciklusban végezzen számításokat.
//-------------------------------------------------------------------------------------
// sheep.mq4
// The code should be used for educational purpose only.
//-------------------------------------------------------------------------------------
int start() // Special function start()
{
//-------------------------------------------------------------------------------------
int
day, // Current day of the month
Mons; // Search amount of months
double
One_Farm =1000.0, // Sheep on the 1st farm
Perc_day =1, // Daily increase, in %
One_Farm_max=50000.0, // Sheep limit
Perc_exit =10, // Monthly output, in %
Purpose =35000.0, // Required amount on farm 2
Two_Farm; // Current amount of farm 2
//-------------------------------------------------------------------------------------
while(Two_Farm < Purpose) // External cycle on history
{ // Start of the external cycle body
//-------------------------------------------------------------------------------
for(day=1; day<=30; day++) // Cycle for days of month
One_Farm=One_Farm*(1+Perc_day/100);//Accumulation on the 1st farm
//-------------------------------------------------------------------------------
Mons++; // Count months
if (One_Farm < One_Farm_max) // If the amount is below limit,.
continue; // .. don't transfer the sheep
Two_Farm=Two_Farm+One_Farm*Perc_exit/100;//Sheep on the 2nd farm
One_Farm=One_Farm*(1-Perc_exit/100);// Remainder on the 1st farm
} // End of the external cycle body
//-------------------------------------------------------------------------------------
Alert("The aim will be attained within ",Mons," months.");//Display on the screen
return; // Exit function start()
}
//-------------------------------------------------------------------------------------

A program kezdetén, ahogy általában változókat írunk le és magyarázuk őket. Magát a számítást a 'while' ciklusban hajtjuk végre. Miután a számítást elvégeztük, a megfelelő üzenetet láthatjuk. A számítások a külső 'while' ciklusban addig folynak, amíg a célt el nem érjük, vagyis amíg a második farmon levő juhok száma el nem eléri a várt 35 000 értékét.

A belső ciklus nagyon egyszerű: az érték naponta 1 százalékkal növekszik. Az összeg elemzését nem hajtjuk végre ebben a ciklusban, mert a probléma felvetés szerint a juhokat csak a hónap végén tudjuk átvinni. Így  a 'for' ciklus végén az  One_Farm változó értéke egyenlő valamennyi juh számával az első farmon. Közvetlenül azután, a Mons változó kiszámolt értéke növekszik 1-el, a külső 'while' ciklus mindegyik ismétlésének a végrehajtásánál.

Az juhok aktuális mennyiségétől függően az első farmon az alábbi két művelet közül az egyiket fogjuk végrehajtani:

  • ha a juhok száma az első farmon meghaladja az 50 000 határértékét, akkor az első farm juhainak 10 százalék át kell helyezni a második farmra;
  • egyéb esetben a juhok maradnak az első farmon és tovább tenyésztik őket.

Az algoritmust elágaztatjuk miközben az 'if' operátort használjuk:

 if (One_Farm < One_Farm_max) // If the amount is below limit,.
continue; // .. don't transfer the sheep

A kódból ezeket a sorokat következőképpen értelmezhetjük: Ha az első farmon levő juhok összege 50 000 alatt van, akkor végrehajtjuk az operátort, az 'if' operátor törzsében. Az első ismétlésnél az első farmon levő juhok  száma kevesebb az előre megadott értéknél, tehát a vezérlés átkerül az 'if' operátor testére,  vagyis a 'continue' operátorra. A ‘continue’ operátor végrehajtása a következőképpen zajlik: Befejezi a aktuális ismétlést a legközelebbi ciklusban (ebben az esetben ez a 'while' ciklusoperátor) és átadja a vezérlést a ciklusoperátor  fejlécébe. Azokat a következő program sorokat, amelyek a 'while’ ciklusoperátor törzsét képezik nem fogjuk végrehajtani:

 Two_Farm = Two_Farm+One_Farm*Perc_exit/100;//Sheep on the 2nd farm
One_Farm = One_Farm*(1-Perc_exit/100); // Remainder on the 1st farm

Ezekben a fenti sorokban a második farmon lévő juh mennyiséget és az első farmon megmaradó juhokat számoltuk ki. Nem szabad ezeket a programsorokat az első ismétléseknél végrehajtani, mert az első farmon a juhok száma az 50000-es határt még nem érte el. Ez a ‘continue’ operátor lényege, kihagyja ezeket a sorokat anélkül, hogy végrehajtanánk őket az aktuális ismétlésben.

Az 'continue' operátor végrehajtásának eredménye az, hogy átadja a vezérlést a 'while' ciklusoperátor fejlécébe. Azután a feltételt a ciklus operátorban teszteljük és a következő ismétlés kezdődik. A ciklust ismét végrehajtjuk ugyanazon algoritmus szerint addig, amíg a juhok száma az első farmon el nem éri az előre definiált határt. A Mons értéke növekszik mindegyik ismétlésnél.

A számolás egy bizonyos szakaszában az első farmon levő juhok száma meg fogja haladni az előre definiált 50000 -es határt. Ebben az esetben, az ‘if'' operátor végrehajtásánál a feltétel (One_Farm <One_Farm_max) hamissá válik és a vezérlés nem fog átkerülni az 'if' operátor törzsébe. Ez azt jelenti, hogy a ‘continue’ operátort nem fogjuk végrehajtani, ezért a vezérlés át fog kerülni a 'while' ciklustörzs utolsó előtti sorába: Először a program úgy fog számolni, mintha a valamennyi juh a második farmon lenne, azután pedig kiszámolja az első gazdaságban maradó juhok számát . Miután ezeket a számításokat befejeztük a 'while' ciklus ismétlése kész lesz, és a vezérlés megint a ciklus fejlécbe kerül. Lent látható ennek az algoritmusnak a blokkdiagramja, amelyet a sheep.mq4  scriptben valósítottunk meg.


47. ábra. Egy program blokkdiagramja ahol a ‘continue’ operátor megszakítja a külső ciklus ismétléseit  (sheep.mq4).

A diagramból láthatjuk, hogy az 'if' operátor feltételétől függően, a vezérlés azonnal átkerül a 'while’ ciklus fejlécébe (a ‘continue’ operátor végrehajtásának eredményeképpen), vagy előbb néhány operátort még végrehajtonk, és csak azután kerül a vezérlés a 'while' ciklus fejlécébe. A ciklus végrehajtása egyik esetben sem ér véget.

Jegyezd meg, a ‘continue’ operátor jelenléte az operátor testben szükségképpen nem vezet az aktuális ismétlés végződéséhez. Ez csak akkor történik meg, ha ez végrehajtják, vagyis ha megkapja a vezérlést.

A 'while' ciklusoperátor mindegyik  ismétlésnél a Two_Farm változó új értéket kap. Amint ez az érték meghaladja az előre definiált határt (35 000), a feltétel a 'while' ciklusoperátorban hamissá fog válni, a számítások a 'while' ciklustörzsben nem fojtatódnak tovább és a vezérlés át fog kerülni ahhoz a legközelebbi operátorhoz, amelyik a ciklusoperátort követi:

 Alert("The aim will be attained within ",Mons," months.");//Display on the screen

Az Alert() függvény  végrehajtása a  következő üzenettel fog végződni:

The aim will be attained within 17 months.


A 'return' operátor befejezi a start() különleges függvény  végrehajtását, ennek következtében a vezérlés átkerül  az ügyfélterminálhoz, és ez a script végrehajtását befejezi, és azt el fogja távolítani a szimbólumablakból.

A fenti algoritmus egy általános kijáratot nyit a 'while' ciklusból. Más esetekben a ciklusból történő kilépést a 'break' operátor végrehajtása is okozhatja (különleges kijárat). Azonban a ciklusból történő kilépés módja nem befolyásolja a ‘continue’ operátor használatát.

Az 'continue' operátor végrehajtás szabályában ”a legközelebbi operátor” kifejezést használtuk. Ez nem azt jelenti, hogy a programsorok közel vannak egymáshoz. Nézzük meg a sheep.mq4. script kódját. Az 'for' operátor ”közelebb” van a 'continue' operátorhoz, mint a 'while' ciklus fejléce. Azonban ez nem jelent semmit: A ‘continue’ operátornak nincs kapcsolata a 'for' ciklussal, mert ez a 'for' ciklustörzsén kívül van. Általában egy program többszörösen egymásba ágyazott ciklusoperátorokat tartalmazhat. A ‘continue’ operátor mindig egy másik operátor törzsében van. Ugyanakkor, a ‘continue’ operátor a belső ciklusoperátor részeként természetesen a külső ciklusoperátor része is. A ”megállítja a legközelebbi ciklus operátor aktuális ismétlésének a végrehajtását” kifejezés azt jelenti, hogy a ‘continue’ operátor azt a legközelebbi ciklusoperátort befolyásolja aelyiknek a törzsén belül lokalizálják. Azért hogy ezt szemléltessük egy kissé változtassuk meg a problémafelvetést.
17. feladat: Az első farmon van 1000 juh. Ezen a farmon a juhok napi 1 százalékot szaporodnak. Azon a napon, amikor a juhok száma meghaladja az 50 000-et a juhok 10 százalékát át kell helyezni egy másik farmra. A második farmon a juhok száma mikor fogja a 35 000-et elérni? (Legyen minden hónapban 30 nap.)

A 17. feladat megoldását az  othersheep.mq4. scriptben valósítjuk meg. Ebben az esetben, az  ‘continue’ operátort használjuk a külső és belső ciklusokban is.

//--------------------------------------------------------------------
// othersheep.mq4
// The code should be used for educational purpose only.
//--------------------------------------------------------------------
int start() // Special function start()
{
//--------------------------------------------------------------------
int
day, // Current day of the month
Mons; // Search amount of months
double
One_Farm =1000.0, // Sheep on the 1st farm
Perc_day =1, // Daily increase, in %
One_Farm_max=50000.0, // Sheep limit
Perc_exit =10, // One-time output, in %
Purpose =35000.0, // Required amount on farm 2
Two_Farm; // Current amount of farm 2
//--------------------------------------------------------------------
while(Two_Farm < Purpose) // Until the aim is attained
{ // Start of the external cycle body
//--------------------------------------------------------------
for(day=1; day<=30 && Two_Farm < Purpose; day++)// Cycle by days
{
One_Farm=One_Farm*(1+Perc_day/100);//Accumulated on farm 1
if (One_Farm < One_Farm_max) // If the amount is below limit,.
continue; // .. don't transfer the sheep
Two_Farm=Two_Farm+One_Farm*Perc_exit/100;//Accumulated on farm 2
One_Farm=One_Farm*(1-Perc_exit/100); //Remainder on farm 1
}
//--------------------------------------------------------------
if (Two_Farm>=Purpose) // If the aim is attained,..
continue; // .. don't count months
Mons++; // Count months
} // End of external cycle body
//--------------------------------------------------------------------
Alert("The aim will be attained within ",Mons," months and ",day," days.");
return; // Exit function start()
}
//--------------------------------------------------------------------

A feladat megoldásához naponta kell elemeznünk a juhok számát. Ezt a célt szolgálják a következő sorok:

 if (One_Farm < One_Farm_max) // If the amount is below limit,.
continue; // .. don't transfer the sheep
Two_Farm=Two_Farm+One_Farm*Perc_exit/100;//Accumulated on farm 2
One_Farm=One_Farm*(1-Perc_exit/100); //Remainder on farm 1

a belső ciklusban a hónap a napjait használjuk. Nyilvánvaló, hogy bizonyos mennyiségű juh átkerül a második farmra, ebben az esetben nem a hónap végén, hanem azon napon, amikor a juhok száma az első farmon éri el az előre definiált értéket. A ‘continue’ operátor használatának oka itt ugyanaz: Ki akarjuk hagyni azokat a sorokat, amelyek olyan számításokat tartalmaznak, amelyekben juh átszállítás történik egy farmról a másikra, vagyis nem akarjuk végrehajtani ezeket a sorokat. Jegyezd meg, a 'while' ciklust nem szakítottuk meg, függetlenül attól, hogy a juhokat átvitték vagy nem, mert a 'continue' operátor csak a legközelebbi ciklusoperátor van hatással és ez az esetünkben a 'for' ciklusoperátor.

Feltételként  egy összetett kifejezést használtunk a 'for' ciklusoperátorban:

 for(day=1; day<=30 && Two_Farm<Purpose; day++)// Cycle by days

Az  && (és) műveletet használjuk, ami azt biztosítja, hogy a ciklust addig fogjuk végrehajtani, amíg mindkét feltétel igaz:

-a hónap nem ért még véget, vagyis a ‘day’ változó az 1- 30 tartományon belül van és

-a második farmon levő juhok összege még nem érte el az előre definiált értéket, a Two_Farm változó kevesebb Purpose-nál (35 000).

Ha a feltételek közül legalább az egyik nem teljesül (hamissá válik), a ciklus megáll. Ha a ciklus végrehajtása leáll (bármilyen okból), a vezérlést átadjuk az 'if' operátornak:

 if (Two_Farm >= Purpose) // If the aim is attained,..
continue; // .. don't count months
Mons++; // Count months

A ‘continue’ operátor használatának ebben a kódban egyszerű oka van: A programnak továbbra is csak hónapokat kell számolnia,akkor  ha a juhok száma a második farmon a várt érték alatt van.  Ha a célt már elértük, a Mons változó értéke nem fog változni, és a vezérlés (a ‘continue’ végrehajtásnak eredményeképpen) át fog kerülni a legközelebbi ciklusoperátor fejlécébe, ami a 'while' ciklusoperátor.

Az ‘continue’ operátorok használatát egymásba ágyazott ciklusokban láthatjuk a 48. ábrán.


48. ábra. Azon algoritmus blokkdiagramja, amely egymásba ágyazott ciklusokon alapult. Mindegyik ciklustestörzs tartalmazza a 'continue' operátort  (othersheep.mq4).

A fenti példában mindegyik ciklusban (külsőben és belsőben) ott van egy-egy  ‘continue' operátor, de azok csak a saját legközelebbi ciklusukat befolyásolják, és semmilyen hatással nincsenek a másik ciklusra. Általában egy ciklustörzsben több ‘continue’ operátor használhatunk, mindegyik egy feltétel teljesülésének eredményeképpen félbeszakítja az aktuális ismétlést. A ‘continue’ operátorok száma egy ciklustesten belül nem korlátozott.