Ковалев Сергей. Программирование на алгоритмическом языке MQL4
Подождите немного. Документ загружается.
81
Стандартная функция Alert() открывает диалоговое окно, в котором отображаются
значения передаваемых параметров. В данном случае в качестве передаваемых
параметров функция получила два значения:
- значение строковой константы: Гипотенуза =
- значение целой переменной С: 5
Выше было указано, что не все функции обязательно должны возвращать значение
(являющееся результатом исполнения функции). Стандартная функция Alert() не
возвращает никакого значения, т.к. у неё другая задача - отображать текст на экране в
специально предназначенном для этого окне.
В результате исполнения стандартной функции Alert() в окне этой функции появится
следующая строка:
Гипотенуза = 5
12. Последний в этой программе оператор завершает работу специальной функции start().
return; // Оператор выхода из функции
На этом работа программы заканчивается.
Может возникнуть вопрос: как узнать, какая функция возвращает значение, а какая - нет?
Ответ на этот вопрос очевиден: для получения подробного описания стандартных
функций необходимо обратиться к справочной документации на MQL4.community, сайте
MetaQuotes Software Corp., или к разделу "Справка" в редакторе MetaEditor. Свойства
пользовательской функции задаются при её описании. Будет пользовательская функция
возвращать значение или нет - зависит от заложенного в неё алгоритма (решение
принимается программистом на этапе составления программного кода функции).
4.6.11 Пример применения в программе пользовательской функции
Теперь посмотрим, как те же вычисления выполняются в программе, содержащей
пользовательскую функцию (рис. 19). Некоторая часть кода, ранее присутствовавшая в
82
специальной функции start(), теперь отсутствует. Вместо неё там присутствует вызов
пользовательской функции. Но вслед за специальной функцией start() появилось описание
пользовательской функции.
Первые две строки, в которых целые переменные А и В получают численные значения,
остались без изменения. Соответственно, ничего не изменится в части их выполнения:
int A = 3; // Первый катет
int B = 4; // Второй катет
В третьей строке написан оператор присваивания, в правой части которого указан вызов
пользовательской функции:
int C = Gipo(A,B); // Вычисление гипотенузы
6. Выполняя этот оператор, программа прежде всего обратится к пользовательской
функции.
Обратите внимание: описание пользовательской функции должно обязательно
присутствовать в программе и располагаться сразу после закрывающей фигурной скобки
специальной функции start() (т.е. за её пределами).
В процессе обращения к пользовательской функции программа выполнит следующие
действия:
6.1. Обращение к переменной А с целью получить её значение (в нашем случае - 3)
6.2. Обращение к переменной В с целью получить её значение (в нашем случае - 4)
Обратите внимание: с самого начала обращения к пользовательской функции
(пользовательской - в данном случае, но это правило распространяется на все функции)
программа получает в своё распоряжение лишь копию значений переменных,
выступающих в роли передаваемых параметров, а изменение значений самих этих
переменных (в данном случае - А и В) в связи с применением пользовательской функции
не предполагается и не происходит.
7. Управление передаётся в пользовательскую функцию.
В течение всего времени исполнения пользовательской функции (как бы долго оно не
происходило) значения переменных в вызывающей программе не пропадают, а
сохраняются.
Первой строкой в описании пользовательской функции является её заголовок:
83
int Gipo(int a, int b) // Пользовательская функция
Исполняя вызванную пользовательскую функцию, программа сделает следующее:
7.1. Переменной а (первой по порядку в списке формальных параметров) будет присвоено
значение 3 (первое по порядку в списке передаваемых параметров).
7.2. Переменной b (второй по порядку в списке формальных параметров) будет присвоено
значение 4 (второе по порядку в списке передаваемых параметров).
Далее управление будет передано в тело функции для исполнения заложенного в неё
алгоритма.
Первым оператором в теле функции стоит такой:
int c2 = a*a + b*b; // Сумма квадратов катетов
7.3. Исполняя этот оператор, программа вычислит значение в правой части оператора
присваивания, а после этого присвоит полученное значение (в нашем случае: 3*3 + 4*4 =
25) переменной с2.
Следующий оператор:
int c = MathSqrt(c2); // Гипотенуза
7.4. Здесь вычисляется квадратный корень из значения переменной с2. Порядок
вычислений такой же, как и в предыдущем примере. Описание стандартной функции
также не используется. В результате выполнения оператора присваивания переменной с
будет присвоено значение 5.
7.5. В следующей строке стоит оператор:
return(c); // Оператор выхода из функции
Исполняя этот оператор, программа вернёт (в точку вызова пользовательской функции)
значение, заключённое в скобки этого оператора. В нашем случае - это значение
переменной с, то есть 5.
На этом исполнение пользовательской функции заканчивается, а управление передаётся в
точку вызова.
8. Напомним, что вызов пользовательской функции произошёл из оператора
int C = Gipo(A,B); // Вычисление гипотенузы
Запись (вызов пользовательской функции)
84
Gipo(A,B)
на этапе возврата значения получает значение, вычисленное в функции (в нашем случае -
это значение 5).
Заканчивая выполнение оператора присваивания, программа присвоит переменной С
значение 5.
9. Следующий оператор
Alert("Гипотенуза = ", C); // Сообщение на экран
будет исполнен так же, как и в предыдущем примере, а именно - в специальном окне
появится сообщение:
Гипотенуза = 5
10. Последний в этой программе оператор
return; // Оператор выхода из функции
завершает работу специальной функции start(), а вместе с ней - и работу всей программы
(более подробно свойства специальных функций рассматриваются в разделе Специальные
функции).
Рассмотрим несколько вариантов реализации представленной выше пользовательской
функции. Легко убедиться, что программирование с применением пользовательских
функций имеет неоспоримые преимущества.
4.6.12 Ранее рассмотренный вариант пользовательской функции
Gipo()
В этой функции формальные параметры "напоминают" переменные, используемые в
основной программе. Однако это - только внешнее сходство, в действительности А и а -
разные имена переменных.
//--------------------------------------------------------------------
int Gipo(int a, int b) // Пользовательская функция
{
int c2 = a*a + b*b; // Сумма квадратов катетов
int c = MathSqrt(c2); // Гипотенуза
85
return(c); // Оператор выхода из функции
}
//--------------------------------------------------------------------
4.6.13 2-й вариант реализации пользовательской функции
В данном случае имена формальных параметров не "напоминают" имена переменных,
использующихся в основной программе, но это не мешает использовать данную функцию
в программе.
//--------------------------------------------------------------------
int Gipo(int alpha, int betta) // Пользовательская функция
{
int SQRT = alpha*alpha + betta*betta; // Сумма квадратов катетов
int GIP = MathSqrt(SQRT); // Гипотенуза
return(GIP); // Оператор выхода из функции
}
//--------------------------------------------------------------------
4.6.14 3-й вариант реализации пользовательской функции Gipo()
В этом примере переменная alpha многократно используется в программе, дважды меняя
своё значение. Это обстоятельство никак не отразится на фактических переменных,
указанных в вызове функции в основной части программы.
//--------------------------------------------------------------------
int Gipo(int alpha, int betta) // Пользовательская функция
{
alpha= alpha*alpha + betta*betta; // Сумма квадратов катетов
alpha= MathSqrt(alpha); // Гипотенуза
return(alpha); // Оператор выхода из функции
}
//--------------------------------------------------------------------
4.6.14 4-й вариант реализации пользовательской функции Gipo()
86
В этой пользовательской функции все вычисления собраны в одном операторе.
Возвращаемое значение вычисляется прямо в скобках оператора return(). Подкоренное
выражение вычисляется прямо там, где должен быть указан передаваемый параметр в
стандартной функции MathSqrt().Такое решение поначалу может показаться непонятным
или неправильным, но в этой реализации пользовательской функции ошибки нет.
Количество используемых в функции операторов меньше, чем в других примерах, код
получается более компактным.
//--------------------------------------------------------------------
int Gipo(int a, int b) // Пользовательская функция
{
return(MathSqrt(a*a + b*b)); // Оператор выхода из функции
}
//--------------------------------------------------------------------
Таким образом, применение пользовательских функций в практике программирования
имеет неоспоримые достоинства:
имена переменных в основном тексте программы никак не связаны с именами
формальных параметров в пользовательской функции;
пользовательские функции могут многократно применяться в различных программах, для
этого нет необходимости изменять код пользовательской функции;
возможно создание библиотек.
Эти очень полезные свойства функций позволяют вести корпоративную работу по
созданию больших программ. В этом процессе возможно участие одновременно
нескольких программистов, при этом они могут не заботиться о согласовании
используемых имён переменных. Достаточно согласовать порядок следования
переменных в заголовке и вызове функции.
4.7 Виды программ
Приступая к созданию программы на MQL4, программист должен, прежде всего, ответить
на вопрос о том, к какому виду программ она будет относиться. От этого зависят её
содержание и функциональные возможности. В языке MQL4 различают 3 вида
прикладных программ: эксперты, скрипты и пользовательские индикаторы. Любая
87
программа, созданная программистом, будет относиться к одному из этих видов. Все они
имеют своё назначение и особенности. Рассмотрим эти характеристики.
Эксперт (Expert Advisor) - программа, составленная на языке MQL4 и вызываемая
клиентским терминалом для исполнения на каждом тике. Основным назначением
экспертов является программное управление торговыми операциями. Эксперты создаются
пользователями. В клиентском терминале отсутствуют встроенные эксперты.
Скрипт - программа, составленная на языке MQL4 и исполняемая клиентским терминалом
однократно. Назначением скриптов является выполнение любых разрешённых операций,
которые требуется выполнить только один раз. Скрипты создаются пользователями,
клиентский терминал встроенными скриптами не укомплектован.
Пользовательский индикатор - программа, составленная на языке MQL4 и вызываемая
клиентским терминалом для исполнения на каждом тике. Основным назначением
индикаторов является отображение на экране линий заданных зависимостей. У
индикаторов отсутствует возможность осуществления торговых операций. Различают два
вида индикаторов - технические (встроенные) и пользовательские. Подробно индикаторы
рассматриваются в разделах Использование технических индикаторов и Создание
пользовательских индикаторов.
Выбор программистом вида вновь создаваемой программы зависит от того, что именно
будет делать программа, а также от свойств и ограничений, имеющихся у программ
разного вида.
4.7.1 Свойства программ
4.7.2 Запуск программы на исполнение
Существует критерий, отличающий эксперты и пользовательские индикаторы от
скриптов. Это - длительность работы программы. В разделе Некоторые основные понятия
уже упоминалось, что программы запускаются на исполнение кратно тикам. Это
88
утверждение справедливо в отношении экспертов и пользовательских индикаторов, но
несправедливо в отношении скриптов.
Эксперт и пользовательский индикатор. После присоединения к окну финансового
инструмента программа (эксперт или пользовательский индикатор) выполняет
подготовительные операции и переходит в режим ожидания тика. При поступлении тика
программа запускается клиентским терминалом на выполнение, исполняет все действия,
заложенные в её алгоритме, и по окончании исполнения передаёт управление
клиентскому терминалу - переходит в режим ожидания тика.
Если новый тик приходится на время исполнения программы, то это не оказывает
никакого влияния на исполнение программы - программа продолжает исполняться в
соответствии с алгоритмом и лишь по окончании исполнения передаёт управление
клиентскому терминалу. Поэтому не все тики приводят к запуску эксперта и
пользовательского индикатора на исполнение, а только те, которые поступают в период,
когда управление передано клиентскому терминалу и программа находится в режиме
ожидания нового тика.
Новый тик снова запускает программу на выполнение. Таким образом, эксперт и
пользовательский индикатор могут находиться в работе в течение длительного времени,
оставаясь присоединёнными к окну финансового инструмента и периодически (кратно
тикам) включаясь в практическую работу.
Существует также разница между порядком исполнения эксперта и индикатора при
первом запуске программы. Эта разница определяется свойствами специальных функций
программы определённого вида (см. Специальные функции). После присоединения к окну
финансового инструмента эксперт выполняет подготовительные операции (функция init())
и переходит в режим ожидания тика для запуска функции start(). В отличие от экперта,
индикатор не только выполняет функцию init(), но и однократно производит вызов
функции start() для первого предварительного расчета значения индикатора. В
дальнейшем при поступлении тика программа запускается вызовом только функции
start(), то есть исполняются операторы в соответствии с алгоритмом функции start().
Скрипт. В отличие от эксперта и пользовательского индикатора, скрипт запускается на
исполнение сразу же после присоединения к окну финансового инструмента, не
дожидаясь поступления тика. Весь код скрипта выполняется один раз, а после того как все
программные строки исполнены, скрипт заканчивает свою работу и выгружается из окна
финансового инструмента. Скрипт удобно использовать для выполнения разовых
89
операций, например, для открытия или закрытия ордеров, для отображения на экране
текстовой информации, установки графических объектов и пр.
Разница в исполнении экспертов, скриптов и пользовательских индикаторов, определяется
свойствами их специальных функций, которые мы рассмотрим более подробно в разделе
Специальные функции.
4.7.3 Осуществление торговых операций
Одним из главных критериев, отличающих программы, является возможность
формирования торговых приказов. Торговый приказ - это управляющее воздействие,
передаваемое программой на сервер, с целью открытия, закрытия или модификации
ордеров. Торговые приказы формируются в программах с помощью встроенных функций,
называющихся торговыми.
Правом использования торговых функций обладают только эксперты и скрипты (и только
в том случае, если включена соответствующая опция в настройках эксперта или скрипта).
Использование торговых функций в пользовательских индикаторах запрещено.
4.7.4 Одновременное использование
Существует также отличие в количестве программ разного вида, одновременно
присоединённых в окно финансового инструмента.
Эксперт. В окне финансового инструмента одновременно можно присоединить только
один эксперт; одновременное использование нескольких экспертов запрещено.
Скрипт. В окне финансового инструмента одновременно можно присоединить только
один скрипт; одновременное использование нескольких скриптов запрещено.
Пользовательский индикатор. В окне финансового инструмента одновременно могут быть
присоединены несколько индикаторов, не мешая работе друг друга.
Все виды программ могут быть одновременно запущены в одном окне финансового
инструмента при условии соблюдения ограничений, имеющихся у каждого вида.
90
Например, можно одновременно запустить на выполнение один эксперт, один скрипт и
несколько индикаторов или один эксперт и один индикатор; но в одном окне нельзя
запустить на выполнение несколько экспертов или несколько скриптов, независимо от
наличия программ других видов.
В то же время разрешено одновременное использование программ одного вида в разных
окнах одного финансового инструмента. Например, если есть необходимость запустить на
выполнение два эксперта по одному финансовому инструменту, то можно один из них
запустить в одном окне, а другой - в другом. В этом случае эксперты будут работать
одновременно. Однако при этом необходимо учитывать, что эксперты, запущенные на
исполнение таким способом, могут формировать противоречивые торговые приказы.
Например, один из экспертов может отдавать приказы на открытие, а другой - на закрытие
ордеров, в результате чего может возникнуть длинная последовательность бесполезных
торговых операций, результатом которой будет общий убыток.
Все виды программ могут создавать глобальные переменные клиентского терминала,
доступные всем другим программам, запущенным в клиентском терминале, в том числе в
окнах разных финансовых инструментов. Это позволяет скоординировать одновременную
работу всех программ. Порядок использования глобальных переменных будет
рассматриваться в разделе Переменные GlobalVariable.
4.7.5 Вызов программ на исполнение
Программы всех видов запускаются на выполнение только по инициативе пользователя. В
языке MQL4 не существует возможности вызвать на исполнение эксперт, скрипт или
индикатор программным способом.
Исключение составляет использование встроенной функции iCustom(), позволяющей
обратиться к пользовательскому индикатору для получения некоторых данных, а также
функций технических индикаторов. При этом факт обращения к функции iCustom() или к
функциям технических индикаторов не приводит к отображению индикаторных линий в
окне финансового инструмента (см. Простые программы на MQL4).
Таблица 2. Основные свойства экспертов, скриптов и пользовательских индикаторов.