Язык программирования MQL4

D; // Заданная точность

//--------------------------------------------------------------------

A=1; // Начальное значение

B=1; // Начальное значение

C=2; // Начальное значение

D=0.0000000001; // Задаём точность

Delta=1000.0; // Начальное значение

//--------------------------------------------------------------------

while(Delta > D) // Заголовок оператора цикла

{ // Скобка начала тела цикла

i++; // Счётчик

A=B; // Следующее значение

B=C; // Следующее значение

C=A + B; // Следующее значение

Delta=MathAbs(C/B - B/A); // Искомая разница между Кф

} // Скобка конца тела цикла

//--------------------------------------------------------------------

Alert("C=",C," Число Фибоначчи=",C/B," i=",i);//Сообщение на экран

return; // Выход из start()

}

//--------------------------------------------------------------------

В начале программы производится объявление переменных (и даётся их описание). В

последующих строках переменным присваиваются численные значения. А, В и С

получают значения первых чисел последовательности Фибоначчи. Здесь необходимо

отметить, что, хотя в самой последовательности идёт речь о целых числах, частное от их

деления должно быть учтено в программе как действительное число. Если бы в данном

случае был использован тип int для этих чисел, то не было бы возможности вычислить

коэффициент Фибоначчи, например, 8/5 = 1 (целое число 1, то есть без дробной части).

Поэтому в данном случае использован тип переменных double. Собственно оператор

цикла выглядит так:

while(Delta > D) // Заголовок оператора цикла

{ // Скобка начала тела цикла

i++; // Счётчик

A=B; // Следующее значение

B=C; // Следующее значение

C=A + B; // Следующее значение

Delta=MathAbs(C/B - B/A); // Искомая разница между Кф

} // Скобка конца тела цикла

Рассмотрим функциональную схему оператора цикла while:

151

Рис. 42. Функциональная схема исполнения оператора while в программе fibonacci.mq4.

Оператор цикла начинает свою работу с проверки условия. Многократное выполнение

цикла будет повторяться до тех пор, пока условие (Delta>D) является истинным.

Понимание кода программы существенно упрощается, если при чтении операторов

произносить ключевую фразу - правило исполнения. Например, при чтении оператора

while это фраза: "До тех пор пока .., выполнять следующее: ..". В данном случае заголовок

оператора while звучит так: до тех пор, пока Delta больше D, выполнять следующее.. И

далее можно перейти к анализу программных строк, составляющих тело цикла и

исполняемых в случае истинности этого Условия.

Перед тем как управление в приведенном примере fibonacci.mq4 передано оператору

цикла while, значения этих переменных соответственно равны 1000.0 и 0.0000000001,

поэтому при первом обращении к оператору цикла условие является истинным. Это

значит, что после проверки условия управление будет передано первому оператору,

составляющему тело оператора цикла.

В данном примере - это оператор:

i++; // Счётчик

В трёх последующих строках вычисляются значения очередного набора элементов

последовательности:

A = B; // Следующее значение

B = C; // Следующее значение

C = A + B; // Следующее значение

152

Легко увидеть, что переменные принимают значения следующих (ближайших больших)

элементов. Если до исполнения оператора цикла значения А, В и С были равны

соответственно 1.0, 1.0 и 2.0, то в процессе первой итерации эти переменные принимают

значения 1.0, 2.0 и 3.0.

Итерация - повторное выполнение некоторых вычислений; используется для обозначения

факта исполнения программных строк, составляющих тело оператора цикла.

В следующей строке вычисляется интересующая нас разница между коэффициентами

Фибоначчи, полученным на основе последующих (C/B) и предыдущих (B/A) элементов

последовательности:

Delta = MathAbs(C/B - B/A); // Искомая разница между Кф

В этом операторе используется стандартная функция MathAbs(), вычисляющая

абсолютное значение выражения. Ранее указывалось, что по мере увеличения значений

элементов последовательности, коэффициенты Фибоначчи принимают поочерёдно то

большие, то меньшие значения, в сравнении с "эталоном". Поэтому разница между

соседними коэффициентами будет принимать то отрицательное, то положительное

значение. В то же время, нас интересует собственно величина этого отклонения, т.е. её

абсолютное значение. Таким образом, независимо от того, в какую сторону отклонилось

текущее значение коэффициента Фибоначчи, значением выражения MathAbs(C/B - B/A), а

также значением переменной Delta, всегда будет положительное число.

Этот оператор является последним в списке операторов, составляющих тело цикла, о чём

свидетельствует наличие в следующей строке закрывающей фигурной скобки. После

исполнения последнего оператора тела цикла управление передаётся в заголовок

оператора цикла для проверки условия. В этом состоит ключевой момент, определяющий

сущность оператора цикла. В зависимости от того, является ли теперь истинным условие

оператора цикла, управление будет передано либо на очередную итерацию в тело цикла,

либо за пределы оператора цикла.

На первых итерациях значение переменной Delta оказывается больше значения, заданного

в переменной D. Это означает, что условие (Delta > D) является истинным, поэтому

управление будет передано в тело цикла на следующую итерацию. Все переменные,

участвующие в вычислениях, получат новые значения, и после достижения конца тела

цикла управление снова будет передано в заголовок для проверки истинности условия.

Этот процесс будет продолжаться до тех пор, пока условие оператора цикла не станет

ложным. В момент, когда значение переменной Delta окажется меньше или равным

153

значению D, условие (Delta > D) перестанет соответствовать истине, а значит управление

будет передано за пределы оператора цикла, в строку:

Alert("C=",C," Число Фибоначчи=",C/B," i=",i);//Сообщение на экран

В результате на экране появится окно оператора Alert(), в котором будет напечатано

следующее:

С=317811 Число Фибоначчи=1.618 i=25

Это означает, что на 25-й итерации заданная точность достигнута, при этом максимальное

значение элемента последовательности Фибоначчи, которое было обработано, равно

317811, а сам коэффициент Фибоначчи, как и ожидалось, равен 1.618. Это сообщение

является решением поставленной задачи.

Здесь нужно заметить, что действительные числа в MQL4 вычисляются с точностью до

15-го знака. В то же время, коэффициент Фибоначчи отражён с точностью до 3-го знака.

Это произошло потому, что свойством функции Alert() является отображение чисел с

точностью до 4-го знака, но все последние ноли при этом не отображаются. Если бы у нас

возникла необходимость отобразить на экране число Фибоначчи с некоторой наперёд

заданной точностью, то нам пришлось бы несколько изменить код, например, так:

Alert("C=",C," Число Фибоначчи=",C/B*10000000," i=",i);// Сообщение

Особо нужно отметить следующее:

Возможна ситуация, при которой условие, указанное в заголовке

оператора цикла, всегда будет оставаться истинным, в результате чего

происходит зацикливание.

Зацикливание - бесконечное повторяющееся выполнение операторов, составляющих тело

цикла; критическая ситуация, возникающая в результате реализации ошибочного

алгоритма.

При зацикливании программа бесконечно исполняет блок операторов, составляющих тело

цикла. Вот простой пример оператора цикла while с зацикливанием:

int i=1; // Формальн параметр (счётчик)

while (i > 0) // Заголовок оператора цикла

i++; // Увеличение значения i

154

В данном примере происходит накапливание (увеличение значения) переменной i на

каждой итерации. В результате условие никогда не станет ложным. Аналогичная ситуация

возникает в случае, когда в теле цикла вообще ничего не вычисляется. Например, в этом

коде:

int i=1; // Формальн параметр (счётчик)

while (i > 0) // Заголовок оператора цикла

Alert("i= ",i); // Сообщение на экран

значение переменной i в цикле не изменяется. На каждой итерации на экран будет

выводиться сообщение:

i= 1

Этот процесс будет повторяться бесконечно. Однажды попав в ловушку зацикленного

кода, управление уже не может выйти из него. Особенно опасна эта ситуация в

торгующих экспертах и скриптах. В таких случаях обычно не обновляются переменные

окружения, т.к. специальная функция не заканчивает свою работу, а о факте зацикливания

пользователю может быть ничего не известно. В результате управление в выполняемой

программе не может быть передано в соответствующие программные строки, где

принимается решение о закрытии или открытии ордеров.

Задача программиста состоит в том, чтобы не допустить возникновение условий, при

которых неконтролируемое зацикливание становится возможным. Не существует метода,

с помощью которого можно было бы обнаружить эту ситуацию программным способом

ни на этапе компиляции программы, ни при её выполнении. Единственным возможным

средством для выявления подобных алгоритмических ошибок является внимательный

анализ кода - логические рассуждения и здравый смысл

7.4 Оператор циклa for

Вторым оператором цикла является оператор for.

7.4.1 Формат оператора for

Полноформатный оператор цикла for состоит из заголовка, содержащего Выражение_1,

Условие и Выражение_2, и исполняемого тела цикла, обрамлённого фигурными скобками.

155

for (Выражение_1; Условие; Выражение_2) // Заголовок оператора

цикла

{ // Открывающая фигурная

скобка

Блок операторов, // Тело цикла может

состоять ..

составляющих тело цикла //.. из нескольких

операторов

} // Закрывающая фигурная

скобка

Если в операторе for тело цикла составляет один оператор, то фигурные скобки можно

опустить.

for (Выражение_1; Условие; Выражение_2) // Заголовок оператора

цикла

Один оператор, тело цикла // Тело цикла - один

оператор

Допускается отсутствие Выражения_1, Условия и Выражения_2. При этом наличие

разделяющего знака ; (точка с запятой) обязательно.

for ( ; Условие; Выражение_2) // Отсутствует

Выражение_1

{ // Открывающая фигурная

скобка

Блок операторов, // Тело цикла может

состоять ..

составляющих тело цикла //.. из нескольких

операторов

} // Закрывающая фигурная

скобка

// -

-----------------------------------------------------------------------------

----

for (Выражение_1; ; Выражение_2) // Отсутствует Условие

{ // Открывающая фигурная

скобка

Блок операторов, // Тело цикла может

состоять ..

составляющих тело цикла //.. из нескольких

операторов

} // Закрывающая фигурная

скобка

156

// -

-----------------------------------------------------------------------------

----

for ( ; ; ) // Отсутств. Выражения

и Условие

{ // Открывающая фигурная

скобка

Блок операторов, // Тело цикла может

состоять ..

составляющих тело цикла //.. из нескольких

операторов

} // Закрывающая фигурная

скобка

7.4.2 Правило исполнения оператора for

При передаче управления оператору for исполнить Выражение_1. Пока

Условие оператора for является истинным: передать управление

первому оператору тела цикла, а после выполнения всех операторов

тела цикла исполнить Выражение_2 и передать управление в заголовок

для проверки истинности Условия. Если Условие оператора for

является ложным, то: передать управление оператору, следующему за

оператором for.

Посмотрим, как работает оператор цикла for. Для этого решим задачу.

Задача 13. Дана последовательность целых чисел: 1 2 3 4 5 6 7 8 9 10 11

...Составить программу, вычисляющую сумму элементов этой

последовательности, начиная с номера N1, заканчивая номером N2.

С точки зрения математики эта задача решается просто. Предположим, необходимо

высчитать сумму элементов с третьего по седьмой. Решением будет сумма: 3 + 4 + 5 + 6 +

7 = 25. Такое решение годится только для частного случая, когда номера первого и

157

последнего элементов, составляющих сумму, равны соответственно 3 и 7. Программа

должна быть составлена так, чтобы при необходимости вычисления суммы в другом

интервале последовательности (например, от 15-го до 23-го элемента) можно было легко

заменить численные значения номеров элементов в одном месте, не меняя программные

строки в других местах. Вот один из вариантов такой программы (скрипт sumtotal.mq4):

//--------------------------------------------------------------------

// sumtotal.mq4

// Предназначен для использования в качестве примера в учебнике MQL4.

//--------------------------------------------------------------------

int start() // Специальная функция start()

{

//--------------------------------------------------------------------

int

Nom_1, // Номер первого элемента

Nom_2, // Номер второго элемента

Sum, // Сумма чисел

i; // Формальн параметр (счётчик)

//--------------------------------------------------------------------

Nom_1=3; // Задаём численное значение

Nom_2=7; // Задаём численное значение

for(i=Nom_1; i<=Nom_2; i++) // Заголовок оператора цикла

{ // Скобка начала тела цикла

Sum=Sum + i; // Сумма накапливается

Alert("i=",i," Sum=",Sum); // Сообщение на экран

} // Скобка конца тела цикла

//--------------------------------------------------------------------

Alert("После выхода из цикла i=",i," Sum=",Sum);// Вывод на экран

return; // Выход из start()

}

//--------------------------------------------------------------------

В первых строках программы объявлены переменные (с комментариями, поясняющими

смысл каждой переменной). В строках

Nom_1 = 3; // Задаём численное значение

Nom_2 = 7; // Задаём численное значение

численно определены значения первого и последнего элементов интервала. Обратите

внимание, нигде в других местах программы эти значения не указываются. При

необходимости эти значения можно легко изменить (в одном месте), не меняя код в

других строках, и задача будет решена для другого интервала. После выполнения

последнего из этих операторов управление передаётся оператору цикла for:

for(i=Nom_1; i<=Nom_2; i++) // Заголовок оператора цикла

{ // Скобка начала тела цикла

158

Sum = Sum + i; // Сумма накапливается

Alert("i=",i," Sum=",Sum); // Сообщение на экран

} // Скобка конца тела цикла

Ключевая фраза - правило исполнения оператора for такая: "Начиная с .., до тех пор пока..,

с шагом.. выполнять следующее: ..". Употребление слов "с шагом" уместно в том случае,

если в качестве Выражения_2 используется накопительный счётчик, например, i++ или

i=i+2. В данном примере ключевая фраза звучит так: начиная с i, равного Nom_1, до тех

пор, пока i меньше или равно Nom_2, с шагом 1 выполнять следующее: (и далее - анализ

тела цикла).

В соответствии с правилом исполнения оператора for в этом блоке программы будет

выполнено следующее:

1. Исполнение Выражения_1:

i=Nom_1

Переменная i получит численное значение переменной Nom_1, т.е. целое число 3.

Выражение_1 выполняется один раз, - в тот момент, когда управление передаётся

оператору for и ни в каких последующих событиях Выражение_1 не участвует.

2. Выполняется проверка Условия:

i<=Nom_2

Значение переменной Nom_2 на первой итерации - целое число 7, а значение переменной i

равно 3. Это значит, что Условие является истинным (т.к. 3 меньше 7), а значит,

управление будет передано в тело цикла для его исполнения.

3. В данном примере тело цикла составляют два оператора, которые будут

последовательно исполнены:

Sum = Sum + i; // Сумма накапливается

Alert("i=",i," Sum=",Sum); // Сообщение на экран

Переменная Sum не получила при инициализации какое-либо начальное значение,

поэтому до начала первой итерации её значение равно нулю. В процессе вычислений

значение переменной Sum увеличивается на величину i и по окончании первой итерации

равно 3. Это значение можно увидеть в окне функции Alert() :

i=3 Sum=3

159

4. Последним событием, которое происходит при выполнении оператора цикла, является

исполнение Выражения_2:

i++

Значение переменной i увеличивается на единицу. На этом заканчивается первая

итерация, и управление передаётся на проверку Условия.

Далее начинается вторая итерация, пункты 2 - 4. В процессе вычислений переменные

получают новые значения. В частности, на второй итерации значение переменной i будет

равно 4, а Sum будет равно 7, о чём появится соответствующее сообщение. В целом,

события в этой программе будут развиваться в соответствии со схемой:

Рис. 43. Функциональная схема исполнения оператора цикла for в программе

sumtotal.mq4.

Программа будет циклически повторять исполнение оператора цикла, до тех пор, пока

Условие не окажется ложным. Это произойдёт, когда значение переменной i будет равно

8, т.е. больше заданного значения переменной Nom_2, равного 7. В этом случае

управление будет передано за пределы оператора for, а именно в строку:

Alert("После выхода из цикла i=",i," Sum=",Sum);// Вывод на экран

и дальше, на исполнение оператора return, завершающего работу специальной функции

start().

160

Язык программирования MQL4

Подождите немного. Документ загружается.