A 'continue' operátor

 continue;   // 'continue' operátor

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

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

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.

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

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.

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:

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.

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.