Ковалев Сергей. Программирование на алгоритмическом языке MQL4
Подождите немного. Документ загружается.
121
// Предназначен для использования в качестве примера в учебнике MQL4.
//--------------------------------------------------------------------
int Count=0; // Глобальная перемен.
//--------------------------------------------------------------------
int init() // Спец. ф-ия init()
{
Alert ("Сработала ф-ия init() при запуске"); // Сообщение
return; // Выход из init()
}
//--------------------------------------------------------------------
int start() // Спец. ф-ия start()
{
double Price = Bid; // Локальная перемен.
Count++; // Счётчик тиков
Alert("Новый тик ",Count," Цена = ",Price);// Сообщение
return; // Выход из start()
}
//--------------------------------------------------------------------
int deinit() // Спец. ф-ия deinit()
{
Alert ("Сработала ф-ия deinit() при выгрузке"); // Сообщение
return; // Выход из deinit()
}
//--------------------------------------------------------------------
В соответствии с правилами исполнения программ (см. Структура программы и
Специальные функции) этот эксперт будет работать так:
1. В момент присоединения программы к окну финансового инструмента клиентский
терминал передаст управление программе, в результате чего программа начнёт
исполняться. Исполнение программы начнётся с головной части. В головной части
программы указана всего одна строка:
int Count=0; // Глобальная перемен.
В этой строке объявлена глобальная переменная Count, инициализированная нулевым
значением. (Локальные и глобальные переменные подробно рассматриваются в Виды
переменных. Здесь только нужно отметить, что алгоритм, используемый в этой
конкретной программе, предполагает обязательное объявление переменной Count как
глобальной, поэтому она не может быть объявлена внутри какой-либо функции, а должна
быть объявлена за пределами описаний функций, т.е. в головной части; в результате этого
значение глобальной переменной Count будет доступно из любого места программы.)
122
2. После исполнения головной части программы будет запущена на исполнение
специальная функция init(). Обратите внимание, вызов этой функции на исполнение нигде
в коде программы не содержится. Запуск на исполнение специальной функции init()
эксперта в момент присоединения программы к окну финансового инструмента является
собственным свойством этой функции. Клиентский терминал вызовет на исполнение
специальную функцию init() просто потому, что в коде программы имеется её описание. В
рассматриваемой программе описание специальной функции init() такое:
int init() // Спец. ф-ия init()
{
Alert ("Сработала ф-ия init() при запуске"); // Сообщение
return; // Выход из init()
}
В теле функции содержится всего два оператора.
2.1 Функция Alert() выводит окно сообщения:
Сработала ф-ия init() при запуске
2.2 Оператор return заканчивает работу специальной функции init()
В результате исполнения функции init() будет напечатано сообщение. В реально
используемых программах такой алгоритм встречается редко, потому что от такого
применения init() мало пользы. В самом деле, нет никакого смысла использовать
функцию, которая просто уведомляет трейдера о том, что она исполняется. Здесь этот
алгоритм применён лишь для того, чтобы проиллюстрировать факт исполнения
специальной функции init(). Обратите внимание: специальная функция init() будет
исполнена в программе всего один раз. Исполнение указанной функции произойдёт в
начале работы программы, сразу после обработки головной части. В момент, когда в
специальной функции init() исполнится оператор return, программа передаст управление
клиентскому терминалу.
3. Клиентский терминал обнаружил в программе описание специальной функции start():
int start() // Спец. ф-ия start()
{
double Price = Bid; // Локальная перемен.
Count++;
Alert("Новый тик ",Count," Цена = ",Price);// Сообщение
return; // Выход из start()
}
123
31. Управление удерживается клиентским терминалом. Клиентский терминал ждёт новый
тик и до прихода нового тика не запускает на исполнение ни одну из функций программы.
Это значит, что некоторое время программа не работает, т.е. в программе не производится
никаких действий. Возникает пауза, хотя нигде в программе нет прямого или косвенного
указания на выполнение этой паузы. Необходимость ожидания тика является
собственным свойством специальной функции strart() эксперта, и не существует
возможности программно повлиять на это свойство (например, отключить). Программа
будет находиться в ожидании управления до тех пор, пока не придёт новый тик. В момент
прихода тика клиентский терминал передаст управление программе, а именно
специальной функции start() (в данном случае в соответствии со свойством функции start()
эксперта), в результате чего начнётся её исполнение.
32 (1). В строке
double Price = Bid; // Локальная переменная
производятся следующие действия:
32.1(1). Объявление локальной переменной Price (см. Виды переменных). Значение этой
локальной переменной будет доступно из любого места специальной функции start().
32.2(1). Выполнение оператора присваивания. Переменной Price будет присвоено
значение текущей цены Bid. Новое значение цены появляется всякий раз с приходом
очередного тика (например, на первом тике цена финансового инструмента может
оказаться равной 1.2744).
33(1). Далее будет выполняться строка:
Count++;
Эта, несколько непривычная, запись является полным аналогом записи Count=Count+1;
На момент, когда управление передаётся в эту строку, значение переменной Count равно
нулю. В результате выполнения оператора Count++ значение Count будет увеличено на
единицу. Таким образом, к моменту передачи управления в следующую строку, значение
Count будет равно 1.
34(1). В следующей строке содержится вызов функции Alert():
Alert ("Новый тик ",Count," Цена = ",Price);// Сообщение
Функция напечатает все константы и переменные, перечисленные в круглых скобках.
124
При первом выполнении функции start() программа напечатает Новый тик, затем
обратится к переменной Count, чтобы получить её значение, (при первом выполнении это
значение равно 1), напечатает это значение, вслед за этим напечатает Цена =, и, наконец,
обратится к переменной Price, получит её значение (в нашем примере это значение 1.2744)
и напечатает его.
В результате будет напечатана строка:
Новый тик 1 Цена = 1.2744
35(1). Оператор
return; // Выход из start()
заканчивает работу специальной функции start().
36. Управление возвращается клиентскому терминалу (на период до прихода очередного
тика).
Так исполняется специальная функция start() эксперта. По окончании исполнения
функция start() возвращает управление клиентскому терминалу, а с приходом нового тика
клиентский терминал вновь запускает её в работу. Этот процесс (запуск start() на
исполнение и возврат управления клиентскому терминалу) может поддерживаться долго -
несколько дней или недель. В течение всего этого времени специальная функция start()
будет периодически исполняться. В общем случае, в зависимости от параметров
окружения (новых значений цены, времени, условий торговли и пр.), в специальной
функции start() могут быть выполнены те или иные действия, например, открыт или
модифицирован ордер.
37. С момента прихода нового тика последовательность действий по пп 32 - 36
повторяется. Однако повторяется лишь последовательность выполняемых операторов, но
переменные всякий раз получают новые значения. Рассмотрим отличия между первым и
вторым исполнением специальной функции start().
32 (2). В строке
double Price = Bid; // Локальная переменная
производятся следующие действия:
32.1(2). Объявление локальной переменной Price (без изменений).
125
32.2(2). Выполнение оператора присваивания. Переменной Price будет присвоено
значение текущей цены Bid (новое значение цены появляется всякий раз с приходом
очередного тика, например, на втором тике цена финансового инструмента окажется
равной 1.2745). (есть изменения).
33(2). Далее будет выполняться строка:
Count++;
В момент, предшествующий передаче управления в эту строку, значение переменной
Count (после первого выполнения функции start()) равно 1. В результате выполнения
оператора Count++ значение Count будет увеличено на единицу. Таким образом, при
втором выполнении значение Count будет равно 2 (есть изменения).
34(2). Функция Alert():
Alert ("Новый тик ",Count," Цена = ",Price);// Сообщение
напечатает все константы и переменные (их новые значения), перечисленные в круглых
скобках.
При втором выполнении функции start() программа напечатает Новый тик, затем
обратится к переменной Count, чтобы получить её значение, (при втором выполнении это
значение равно 2), напечатает это значение, вслед за этим напечатает Цена =, и, наконец,
обратится к переменной Price, получит её значение (в нашем примере значение цены при
втором выполнении равно 1.2745) и напечатает его (есть изменения).
В результате будет напечатана строка:
Новый тик 2 Цена = 1.2745
35(2). Оператор
return; // Выход из start()
заканчивает работу специальной функции start() (без изменений).
36(2). Управление возвращается клиентскому терминалу на ожидание нового тика.
37(2). В дальнейшем всё повторяется снова. При третьем выполнении специальной
функции start() переменные получат новые значения и неминуемо будут снова напечатаны
с помощью функции Alert(), т.е. программа снова выполнится по п.п. 32 - 36(3). И далее
снова и снова.. 32 - 36(4), 32 - 36(5),..(6)..(7)..(8)... Если пользователь не предпримет
126
никаких действий, то этот процесс будет повторяться бесконечно. В результате работы
специальной функции start() рассматриваемой программы на экране можно наблюдать
тиковую историю изменения цены.
Следующие события наступят только в тот момент, когда пользователь примет решение о
прекращении работы программы и принудительно, вручную выгрузит программу из окна
финансового инструмента:
4. Клиентский терминал передаст управление специальной функции deinit() (в
соответствии с её свойствами).
int deinit() // Спец. ф-ия deinit()
{
Alert ("Сработала ф-ия deinit() при выгрузке"); // Сообщение
return; // Выход из deinit()
}
В теле функции содержится всего два оператора.
41. Функция Alert() напечатает сообщение:
Сработала ф-ия deinit() при выгрузке
42. Оператор return заканчивает работу специальной функции deinit().
Функция deinit() запускается на исполнение клиентским терминалом один раз, в
результате чего в окне функции Alert() появится указанное сообщение, после чего
программа будет выгружена из окна финансового инструмента.
5. На этом история исполнения эксперта заканчивается.
Присоедините эту показательную программу в окно любого финансового инструмента и
запустите её на выполнение. Выполняющаяся программа отобразит на экране окно, в
котором будут отображены сообщения функции Alert(). Ориентируясь по содержанию
сообщений, легко понять, какая специальная функция причастна к той или иной записи.
127
Рис. 35. Результат работы программы simple.mq4.
На данном примере легко убедиться, что программа исполняется в соответствии со
свойствами специальных функций, указанными в разделе Специальные функции.
Выгрузите и загрузите программу снова. Сделав это несколько раз, Вы получите
небольшой опыт использования своей первой программы. Она будет работать и сейчас и в
следующий раз. В дальнейшем, программы, которые Вы напишете самостоятельно, также
будут построены в соответствии с описанной структурой, и для запуска на исполнение их
также нужно будет присоединять к окну финансового инструмента.
Старайтесь, чтобы ни одно понятие или правило не ускользнуло от Вашего внимания,
тогда процесс составления программ на языке MQL4 окажется лёгким и приятным
занятием.
6.4 Примеры реализации
128
В предыдущем параграфе рассматривался пример исполнения специальных функций в
простом эксперте simple.mq4. Для того, чтобы закрепить материал, необходимо
рассмотреть ещё несколько модификаций этой программы.
Пример правильной структуры программы
Как правило, описания функций в программе указываются в той последовательности, в
которой они вызываются для исполнения клиентским терминалом, а именно, сначала
приводится описание специальной функции init(), затем специальной функции start(), и
последним указывается описание специальной функции deinit(). Однако специальные
функции вызываются для исполнения клиентским терминалом в соответствии с их
собственными свойствами, поэтому не имеет значения, в каком месте программы указано
описание той или иной функции. Давайте переставим местами специальные функции и
посмотрим, что из этого получится (эксперт possible.mq4).
//--------------------------------------------------------------------
// possible.mq4
// Предназначен для использования в качестве примера в учебнике MQL4.
//--------------------------------------------------------------------
int Count=0; // Глобальная перемен.
//--------------------------------------------------------------------
int start() // Спец. ф-ия start()
{
double Price = Bid; // Локальная перемен.
Count++;
Alert("Новый тик ",Count," Цена = ",Price);// Сообщение
return; // Выход из start()
}
//--------------------------------------------------------------------
int init() // Спец. ф-ия init()
{
Alert ("Сработала ф-ия init() при запуске"); // Сообщение
return; // Выход из init()
}
//--------------------------------------------------------------------
int deinit() // Спец. ф-ия deinit()
{
Alert ("Сработала ф-ия deinit() при выгрузке");// Сообщение
return; // Выход из deinit()
}
//--------------------------------------------------------------------
129
Запустив этот эксперт на выполнение, легко убедиться, что порядок исполнения
специальных функций в программе не зависит от порядка следования в программе
описаний специальных функций. Вы можете самостоятельно по своему выбору поменять
местами специальные функции в исходном коде и убедиться, что для любого варианта
результат будет таким же, как и в случае исполнения эксперта simple.mq4.
Пример неправильной структуры программы
Совсем иные события произойдут, если в программе изменить положение головной части.
В данном примере специальная функция start() указана раньше (выше по тексту), чем
головная часть программы (эксперт incorrect.mq4):
//--------------------------------------------------------------------
// incorrect.mq4
// Предназначен для использования в качестве примера в учебнике MQL4.
//--------------------------------------------------------------------
int start() // Спец. ф-ия start()
{
double Price = Bid; // Локальная перемен.
Count++;
Alert ("Новый тик ",Count," Цена = ",Price);// Сообщение
return; // Выход из start()
}
//--------------------------------------------------------------------
int Count=0; // Глобальная перемен.
//--------------------------------------------------------------------
int init() // Спец. ф-ия init()
{
Alert ("Сработала ф-ия init() при запуске"); // Сообщение
return; // Выход из init()
}
//--------------------------------------------------------------------
int deinit() // Спец. ф-ия deinit()
{
Alert ("Сработала ф-ия deinit() при выгрузке");// Сообщение
return; // Выход из deinit()
}
//--------------------------------------------------------------------
При попытке компиляции этого эксперта редактор MetaEditor выдаст сообщение об
ошибке:
130
Рис. 36. Сообщение об ошибках при компиляции программы incorrect.mq4.
В данном случае строка
int Count=0; // Глобальная перемен.
написана за пределами всех функций, но находится не в первых строках программы, а где-
то в середине.
Определяющим моментом в структуре этой программы является то, что объявление
глобальной переменной Count происходит после объявления функции (в данном случае -
специальной функции start()). На данном этапе изложения мы не можем обсуждать
подробности применения глобальных переменных; виды переменных и правила их
использования приведены в разделе Переменные. Здесь достаточно сказать, что любая
глобальная переменная должна быть объявлена раньше (выше по тексту программы), чем
первое обращение к этой переменной (в данном случае из функции start()). В
рассматриваемой программе это правило нарушено, поэтому компилятор сообщил об
ошибке.
Пример применения пользовательской функции
Теперь посмотрим, как программа проявляется в отношении пользовательских функций.
Для этого несколько модернизируем код, представленный в примере простого эксперта
simple.mq4, и подробно его разберём. Программа, содержащая пользовательскую
функцию, будет выглядеть так (эксперт userfunction.mq4):
//--------------------------------------------------------------------
// userfunction.mq4
// Предназначен для использования в качестве примера в учебнике MQL4.
//--------------------------------------------------------------------
int Count=0; // Глобальная перемен.
//--------------------------------------------------------------------
int init() // Спец. ф-ия init()