Добро пожаловать в мир практических курсов MQL4; добро пожаловать в пост где я попробую подробно описать процесс написания индикатора для рынка Форекс в MQL4.
Уверен, этот и последующие несколько постов по программированию на языке MQL4 будут интересны не только теоретикам, но и практикам.

Важно: рекомендую проситать предыдущие посты очень внимательно, прежде, чем переходить к этому и последующим постам. Мы будем очень обширно пользоваться вышеописанном материалом.

Теперь мы создадим простой индикатор, который будет значить немного для нашей торговли, но будет значить очень много для нашего понимания программирования на MQL4.

Он будет просто-напросто рассчитывать разницу High [] – Low []. Не торопитесь, скоро Вы всё поймёте.
Поехали!
Это название той встроенной в MetaTrader 4 программы, которая позволяет Вам писать программы, читать помощь по MQL4, компилировать программы и многое другое.
У меня на рабочем столе есть ярлык MetaEditor, чтобы проще его запускать.
1 — Запустите MT4, затем либо нажмите F4, либо выберите MetaEditor из вкладки «сервис», либо нажмите на значок MetaEditor (см. рис. 1).
2 — Пуск -> Программы -> /Группа MetaTrader 4/ -> MetaEditor .
3 — Зайти в папку установки MT4 (например: C:Program FilesMetaTrader 4), найти MetaEditor.exe и запустить (рекомедую сделать ярлык на рабочем столе).
В любом случае Вы попадаете в программу MetaEditor 4.
1 — Окно редактора. Здесь Вы пишите свою программу.

2 — Окно инструментария. Содержит четыре вкладки:

• Ошибки. Здесь Вам покажут возникшие при компиляции ошибки.
• Поиск в файлах. Здесь Вы можете просматривать файлы, найденные с помощью соотетствующей комманды из вкладки правка (Ctrl+Shift+F).
• Библиотека. Online — библиотека.
• Справка. Выделяете в коде нужное слово и жмёте F1. Появится справка.

3 — Окно навигатора. Содержит три вкладки:

• Файлы. Для простого доступа к файлам, сохранённым в папке MT4.
• Словарь. Доступ к справке по MQL4.
• Поиск. Поиск в справке MQL4.

Советую ознакомиться с окнами MetaEditor.


Заметка: пользовательский индикатор — это программа, которая позволяет Вам использовать функции технического анализа, но не может автоматизировать Ваши сделки.


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

Шаг 1: Нажмите Файл -> Создать (или просто Ctrl + N)
Появится такое окошко:
Выберите пункт «пользовательский индикатор» и нажмите Next.

Шаг 2:
Появится такое окошко:
1 — Имя Вашей программы.
2 — Автор программы.
3 — Ссылка на Ваш сайт или e-mail.
4 — Параметры — список внешних (extern) переменных. Это те переменные, которые пользователь сможет изменять в окошке настроек индикатора (см. урок про переменные).

В нашем примере нам не потребуются внешние переменные. Заполните первые три поля и нажмите Next.

Шаг 3:
Появится такое окошко:
В этом окошке Вы можете устанавливать свойства рисования Вашего индикатора, например: сколько у него будет линий, их цвета, где рисовать Ваш индикатор (на графике цены или в отдельном окне).

1 — Индикатор в отдельном окне. Думаю, понятно, что эта опция делает.
2 — Минимум. Если индикатор рисуется в отдельном окне, эта опция устанавливает нижнюю границу для этого окна.
3 — Максимум. Если индикатор рисуется в отдельном окне, эта опция устанавливает верхнюю границу для этого окна.
4 — Список индексов. Сюда Вы добавляете линии индикатора и ставите их цвет-по-умолчанию.

Далее мы более подробно разберём эти опции, поэтому не спешите.
А сейчас сделайте всё, как на рис. 5.
Когда Вы нажмёте кнопку Finish, начнётся волшебство. Окошко помощника исчезнет, Вы опять окажетесь в MetaEditor и… Угадайте….
Вы получили шаблон для своего первого индикатора.

Примерно такой код Вы получите:
Код:
//+------------------------------------------------------------------+
//| MyFirstIndicator.mq4 |
//| Kirill |
//| StockProgrammer@mail.ru |
//+------------------------------------------------------------------+
#property copyright "Kirill"
#property link "StockProgrammer@mail.ru"

#property indicator_separate_window
#property indicator_buffers 1
#property indicator_color1 Red
//---- buffers
double ExtMapBuffer1[];
//+------------------------------------------------------------------+
//| Custom indicator initialization function |
//+------------------------------------------------------------------+
int init()
 {
//---- indicators
 SetIndexStyle(0,DRAW_LINE);
 SetIndexBuffer(0,ExtMapBuffer1);
//----
 return(0);
 }
//+------------------------------------------------------------------+
//| Custom indicator deinitialization function |
//+------------------------------------------------------------------+
int deinit()
 {
//----

//----
 return(0);
 }
//+------------------------------------------------------------------+
//| Custom indicator iteration function |
//+------------------------------------------------------------------+
int start()
 {
 int counted_bars=IndicatorCounted();
//----

//----
 return(0);
 }
//+------------------------------------------------------------------+
Как Вы видите, помощник написал достаточно много кода за Вас.


Теперь мы добавим пару строк в уже имеющийся код, чтобы программа стала более полезной.
После этого мы разберём весь код строчку за строчкой.

Начнём кодить!

Я выделил жирным код, который нужно добавить.

Цитата:
//+——————————————————————+
//| MyFirstIndicator.mq4 |
//| Kirill |
//| StockProgrammer@mail.ru |
//+——————————————————————+
#property copyright «Kirill»
#property link «StockProgrammer@mail.ru»#property indicator_separate_window
#property indicator_buffers 1
#property indicator_color1 Red
//—- buffers
double ExtMapBuffer1[];
//+——————————————————————+
//| Custom indicator initialization function |
//+——————————————————————+
int init()
{
//—- indicators
SetIndexStyle(0,DRAW_LINE);
SetIndexBuffer(0,ExtMapBuffer1); string short_name = «Your first indicator is running!»;
IndicatorShortName(short_name);//—-
return(0);
}
//+——————————————————————+
//| Custom indicator deinitialization function |
//+——————————————————————+
int deinit()
{
//—-//—-
return(0);
}
//+——————————————————————+
//| Custom indicator iteration function |
//+——————————————————————+
int start()
{
int counted_bars=IndicatorCounted();//—- check for possible errors
if (counted_bars<0) return(-1);
//—- last counted bar will be recounted
if (counted_bars>0) counted_bars—;

int pos=Bars-counted_bars;

double dHigh , dLow , dResult;

Comment(«Hi! I’m here on the main chart window!»);

//—- main calculation loop

while(pos>=0)
{
dHigh = High[pos];
dLow = Low[pos];
dResult = dHigh — dLow;

ExtMapBuffer1[pos]= dResult ;

pos—;

}

//—-

return(0);
}
//+——————————————————————+

Код:
//+------------------------------------------------------------------+
//| MyFirstIndicator.mq4 |
//| Kirill |
//| StockProgrammer@mail.ru |
//+------------------------------------------------------------------+

Комментарии
Первые пять строчек (выделены серым цветом у Вас в редакторе) — это комментарии.
Напомню, что комментарии мы используем для того, чтобы вставлять в код строчки, которые компилятор должен игнорировать.
Есть много причин, по которым могут потребоваться комментарии:
- Сделать код более красивым.
- Задокументировать такие моменты, как право собственности, дату создания и т.д.
- Сделать код понятнее.
- Объяснить, как код работает.

Комментарии бывают однострочные и многострочные (см. предыдущий пост).

В нашей программе помощник собрал введённую нами информацию о названии программы, её авторе и ссылке в самом верху.

Код:
#property copyright "Kirill"
#property link "StockProgrammer@mail.ru"

#property indicator_separate_window
#property indicator_buffers 1
#property indicator_color1 Red

Директива property . (см. предыдущий пост)

#property copyright — здесь хранится имя автора программы. Вы ввели его на втором шаге помощника. Тип данных — string.

#property link — ссылка на Вашу домашнюю страницу или Ваш e-mail. Эти данные Вы также ввели на втором шаге помощника. Тип данных — string.

#property indicator_separate_window — таким образом мы говорим препроцессору, что мы хотим, чтобы наш индикатор рисовался в отдельном окне. Тип данных — void (нет принимаемого значения).
* #property indicator_chart_window — алтернатива — индикатор рисуется в окне графика. Обе опции использовать одновременно нельзя.

#property indicator_buffers 1 — с помощью indicator_buffers мы устанавливаем количество массивов, выделяемых под линии нашего индикатора. В кажлом индикаторе разрешается не больше 8 линий. В нашем случае мы рисуем только одну линию.

#property indicator_color1 Red — indicator_colorN устанавливает цвет линии номер N. Пользователь может изменить этот цвет в настройках индикатора. Тип данных — color.

Код:
//---- buffers
double ExtMapBuffer1[];
Разбор:

Массивы (Arrays)

В жизни мы часто группируем похожие объекты. В программировании тоже очень удобно группировать данные одного типа. Для достижения этой цели используются массивы.
Массив — это упорядоченное множество элементов одного типа. Нумерация в массиве начинается с нуля.
Объявление массива:

Код:
int my_array[50];
Здесь мы объявили массив, в котором может содержатся до 50 (включительно) элементов типа integer.
Доступ к элементу происходит по его индексу.
Например, доступ к 0-вому элементу массива и присваивания ему значения 16 выглядит так:

Код:
my_array[0] = 16;
Массив можно инициализировать в строчке его объявления. Делается это так:

Код:
int my_array[5] = {16,24,15,8901,17}
В нашей программе используется такой код:

Код:
double ExtMapBuffer1[];
Таким образом мы объявили массив типа double. Этот массив мы будем использовать для подсчёта значений, которые необходимо рисовать на графике индикатора.

Код:

Код:
int init()
Разбор:

В MQL4 есть три спец. функции: init(), start(), deinit(). Подробнее — см. пост — Функции.

Код:

Код:
//---- indicators
 SetIndexStyle(0,DRAW_LINE);
 SetIndexBuffer(0,ExtMapBuffer1);

 string short_name = "Your first indicator is running!"; IndicatorShortName(short_name);

//----
Разбор:


Я не могу дать Вам описания всех функций индикаторов в этом посте, но те, которые мы использовали, мы обсудим.

SetIndexStyle():
void SetIndexStyle( int index, int type, int style=EMPTY, int width=EMPTY, color clr=CLR_NONE)
- Устанавливает новый тип, стиль, ширину и цвет для указанной линии индикатора.
index — Порядковый номер линии. Должен быть от 0 до 7. Это потому что у нас может быть всего 8 линий, а нумерация в массиве, где они хранятся начинается с нуля.
type — Стиль отрисовки линии индикатора. Может быть одним из перечисленных стилей отрисовки линии:
DRAW_LINE — Простая линия
DRAW_SECTION — Отрезки между непустыми значениями линии
DRAW_HISTOGRAM — Гистограмма
DRAW_ARROW — Стрелки (символы)
DRAW_ZIGZAG — Отрезки между непустыми значениями чётной и нечётной линий (зигзаг)
DRAW_NONE — Отсутствие какого-либо рисования

style — Стиль линии. Используется для линий толщиной в 1 пиксель. Может быть одним из перечисленных стилей линии. Пустое значение (EMPTY) указывает, что стиль не будет изменен.
DRAW_LINE — Простая линия
DRAW_SECTION — Отрезки между непустыми значениями линии
DRAW_HISTOGRAM — Гистограмма
DRAW_ARROW — Стрелки (символы)
DRAW_ZIGZAG — Отрезки между непустыми значениями чётной и нечётной линий (зигзаг)
DRAW_NONE — Отсутствие какого-либо рисования

width — Ширина линии. Допустимые значения — 1,2,3,4,5. Пустое значение (EMPTY) указывает, что ширина не будет изменена.

clr — Цвет линии. Отсутствие параметра означает, что цвет не будет изменен.

В нашем коде:

Код:
SetIndexStyle(0,DRAW_LINE);
index = 0 — это означает, что мы будем работать с первой (и единственной) нашей линией.
type = DRAW_LINE — это означает, что мы хотим рисовать линию.
Остальные параметры мы оставили по умолчанию.

SetIndexBuffer()

bool SetIndexBuffer(int index, double array[])

- Связывает переменную-массив, объявленный на глобальном уровне, с предопределенным буфером пользовательского индикатора. Количество буферов, необходимых для расчета индикатора, задается с помощью функции IndicatorBuffers() и не может быть больше 8. В случае успешного связывания возвращается TRUE, иначе FALSE. Чтобы получить расширенные сведения об ошибке, следует вызвать функцию GetLastError().

Как мы уже замечали ранее, расчитанные данные для отрисовки на график в нашей программе будут храниться в массиве ExtMapBuffer1[]. Его мы и связываем с нашей единственной линией, имеющей индекс 0.

IndicatorShortName();

void IndicatorShortName(string name)

- Установка «короткого» имени пользовательского индикатора для отображения в подокне индикатора и в окне DataWindow.

Мы в нашей программе завели переменную short_name типа string, которой присвоили значение «Your first indicator is running!». Затем мы передали эту переменную в функцию IndicatorShortName(); .

Код:

Код:
return (0);
Разбор:

Функция init() возвращает 0 и завершает свою работу. Управление переходит функции start().

Код:

Код:
int deinit()
 {
//----

//----
 return(0);
 }
Разбор:

Ничего нового про функцию deinit() сказать не могу.


Выше мы разбирали код нашего индикатора строчку за строчкой и дошли до функции start().
Очень надеюсь, что Вы прекрасно понимаете.
Теперь мы изучим функцию start() и её содержимое, и, наконец-то, мы скомпилируем и запустим наш первый индикатор.
Давайте разберём оставшийся код!

Наш код:

Цитата:
//+——————————————————————+
//| MyFirstIndicator.mq4 |
//| Kirill |
//| StockProgrammer@mail.ru |
//+——————————————————————+
#property copyright «Kirill»
#property link «StockProgrammer@mail.ru»#property indicator_separate_window
#property indicator_buffers 1
#property indicator_color1 Red
//—- buffers
double ExtMapBuffer1[];
//+——————————————————————+
//| Custom indicator initialization function |
//+——————————————————————+
int init()
{
//—- indicators
SetIndexStyle(0,DRAW_LINE);
SetIndexBuffer(0,ExtMapBuffer1);string short_name = «Your first indicator is running!»;
IndicatorShortName(short_name);//—-
return(0);
}
//+——————————————————————+
//| Custom indicator deinitialization function |
//+——————————————————————+
int deinit()
{
//—-//—-
return(0);
}
//+——————————————————————+
//| Custom indicator iteration function |
//+——————————————————————+
int start()
{
int counted_bars=IndicatorCounted();//—- check for possible errors
if (counted_bars<0) return(-1);
//—- last counted bar will be recounted
if (counted_bars>0) counted_bars—;

int pos=Bars-counted_bars;

double dHigh , dLow , dResult;

Comment(«Hi! I’m here on the main chart windows!»);

//—- main calculation loop

while(pos>=0)
{
dHigh = High[pos];
dLow = Low[pos];
dResult = dHigh — dLow;

ExtMapBuffer1[pos]= dResult ;

pos—;

}

//—-

return(0);
}
//+——————————————————————+

Код:

Код:
int start()
 {

 }
Разбор:

Как я Вам уже говорил, мы будем проводить 90% нашей программистской жизни внутри фигурных скобок тела функцииstart(). Это так, потому что она самая важная из всех трёх спец. функций MQL4. В отличии от функций init() и deinit()функция start() не будет вызвана (клиентским терминалом) только единожды. Она будет вызываться при каждом поступление новых котировок. Функция start() возвращает значение типа integer, как и все остальные спец. функции языка MQL4. 0 означает, что функция отработала без ошибок, а любое другое число означает, что произошла ошибка.

Код:

Код:
 int counted_bars=IndicatorCounted();
Разбор:

Здесь мы объявили переменную counted_bars типа integer и инициализировали её значением, возвращаемым функцией IndicatorCounted(); .


- Функция возвращает количество баров, не измененных после последнего вызова индикатора. Большинство подсчитанных баров не нуждается в пересчете. Функция используется для оптимизации вычислений.

Замечание: самый последний бар не считается посчитанным, и в большинстве случаев необходимо пересчитывать только его. Однако бывают пограничные случаи, когда вызов пользовательского индикатора производится из эксперта на первом тике нового бара. Возможна ситуация, что последний тик предыдущего бара не обработан (по той причине, что в момент прихода этого последнего тика обрабатывался предпоследний тик), и пользовательский индикатор не был вызван и поэтому не был рассчитан. Чтобы избежать в такой ситуации ошибок расчета индикатора, функция IndicatorCounted() возвращает реально посчитанное количество баров минус один.

ОЧЕНЬ ВАЖНО: на будущее запомните, что в MQL4 бары нумеруются задом-наперёд. Нулевой бар — это текущий бар, следующий (более старый — левее на графике) — это первый бар, за ним — второй и т.д. При появлении нового бара они все перенумеровываются, и текущий опять становится нулевым.

Код:

Код:
//---- check for possible errors
 if (counted_bars<0) return(-1);
Разбор:

Очевидно, что число баров, не измененных после последнего вызова индикатора должно быть = 0 или > 0. Если же оно < 0, значит произошла ошибка. Мы терминируем функцию start() и сообщаем об ошибке, возвращая не 0.

Код:

Код:
//---- last counted bar will be recounted
 if (counted_bars>0) counted_bars--;
Разбор:

Притворяемся, что посчитано на один бар меньше, чтобы пересчитать последний бар. На самом деле, это перестраховка, т.к. функция IndicatorCounted( ) и так возвращает число на 1 меньше. Но ничего страшного в том, что мы пересчитаем ещё один лишний бар нет. PS: надеюсь, вы помните, что —; — это оператор декремента — уменьшение на единицу.

Код:

Код:
 int pos=Bars-counted_bars;
Разбор:

Здесь мы объявляем переменную pos, которая указывает, сколько раз должен сработать наш счётный цикл (про цикл while см. далее). ‘Функция’ Bars возвращает количество уже имеющихся на графике баров. Чтобы вычислить pos мы из общего количества баров графика вычитаем количество уже посчитанных баров.

Кстати, хороший момент обсудить ‘функцию’ Bars и её братьев.

Предопределённые переменные языка MQL4:

Ask, Bid, Bars, Close, Open, High, Low, Time и Volume — являются функциями, хотя в MQL4 они называются предопределёнными переменными и после них не надо ставить круглые скобки.
И я докажу Вам, что они скорее функции, чем переменные.
Переменная — означает область в памяти + тип данных, который Вы указываете.
Функция — означает сделать что-то и вернуть какое-то значение. Например, Bars считает и возвращает количество баров на графике. Так что же? Это переменная?
Если ввести следующий код:
Bars = 1;
Вы получите ошибку: ‘Bars’ — unexpected token
Это потому что они не переменные, и Вы не можете присваивать им значения.
Итак, обсудим эти функции.

int Bars

Эта функция возвращает значение типа integer, в котором содержится информация о количестве имеющихся на текущем графике барах.

double Ask

Эта функция, используемая преимущественно в советниках, возвращает значение типа double, в котором содержится информация о цене покупки базовой валюты в данной валютной паре.

double Bid

Эта функция, используемая преимущественно в советниках, возвращает значение типа double, в котором содержится информация о цене продажи базовой валюты в данной валютной паре.

Замечание: Например, USD/JPY = 105.11/105.14 — здесь левая цена — это bid (цена, по которой Вы продаёте), правая цена — это ask (цена, по которой Вы покупаете).

double Open[]

Эта функция возвращает значение типа double, в котором содержится информация о цене открытия (далее — везде ‘цена’ — это bid) для указанного бара.

Например: Open[0] вернёт цену открытия текущего бара.

double Close[]

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

Замечание: Т.к. цена закрытия текущего бара ещё никому не известна, Close[0] возвращает текущую цену bid.

double High[]

Эта функция возвращает значение типа double, в котором содержится информация о самой высокой цене (цене high) для указанного бара.

double High[]

Эта функция возвращает значение типа double, в котором содержится информация о самой низкой цене (цене low) для указанного бара.

double Volume[]

Эта функция возвращает значение типа double, в котором содержится информация ( для forex объёмы не контролируются, поэтому: ) о количестве изменений котировки для указанного бара.

int Digits

Эта функция возвращает значение типа integer, в котором содержится информация о количестве знаков после запятой для котировки данной валюты. Обычно 4.

int Point

Эта функция возвращает значение типа double равное одному пункту для данной валютной пары. Обычно 0.0001 .

datetime Time[]

Эта функция возвращает значение типа datetime, в котором содержится информация о времени открытия указанного бара.

Код:

Код:
 double dHigh , dLow , dResult;
Разбор:

Мы объявили три переменные типа double, которые мы используем позже. Заметьте, как мы объявили все три в одной строчке, разделив их запятыми.

Код:

Код:
 Comment("Hi! I'm here on the main chart window!");
Разбор:

В этой строчке мы используем функцию Comment, чтобы распечатать текст «Hi! I’m here on the main chart window!» в левом верхнем углу основного графика.

Всего таких информирующих функции три:

void Comment()

- Функция выводит комментарий, определенный пользователем, в левый верхний угол графика. Параметры могут иметь любой тип. Количество параметров не может превышать 64.

void Print( …)

- Печатает некоторое сообщение в журнал экспертов. Параметры могут иметь любой тип. Количество параметров не может превышать 64.

void Alert( …)

- Отображает диалоговое окно, содержащие пользовательские данные. Параметры могут быть любого типа. Количество параметров не может превышать 64.

Код:
Код:
//---- main calculation loop

 while(pos>=0)
 {
 dHigh = High[pos];
 dLow = Low[pos];
 dResult = dHigh - dLow;

 ExtMapBuffer1[pos]= dResult ;

 pos--;

 }
Пришло время войти в цикл расчёта отображаемых нашим индикатором точек. Любое значение, которое мы положим в массив ExtMapBuffer1[] будет отображено на графике (потому что, используя функцию SetIndexBuffer(), мы связали этот массив с линией, индексируемой нулём).

ОЧЕНЬ ВАЖНО: когда мы связываем массив с линией, массив приобретает ещё одно спец. свойство. При появлении нового бара на графике, все элементы массива сдвигаются влево на один, т.е. N-й становится N+1-ым, … , 1-й становится 2-м, 0-й становится 1-м. Таким образом, высвобождается место для нового нулевого элемента. Это сделано для того,чтобы при пересчёте только новых баров графика, информация о значении индикатора на старых барах сохранялась в элементах масива, индексируемых теми же числами, что и сами бары.

Переменной цикла (она регулирует число его прохождений) у нас является переменная pos. Мы её используем для обращения к неподсчитанным барам. Например High[pos] вернёт максимальное значение цены на баре с индексом pos.
В теле цикла мы присваиваем переменной dHigh значение цены high на баре pos.
Аналогично, мы присваиваем переменной dLow значение цены low на баре pos.
Разницу dHigh — dLow мы присваиваем переменной dResult.
Затем Мы используем dResult для отрисовки линии индикатора, присваивая его значение соответствующему элементу массива ExtMapBuffer1[] (элементу с индексом pos).
Последняя строчка цикла — мы применяем оператор декремента к переменной цикла pos. Когда, pos станет = -1, цикл завершит свою работу.


Нажмите F5 или нажмите кнопку Компилировать.
В результате сгенерируется исполняемый файл «MyFirstIndicator.ex4″, который Вы можете запустить в своём терминале.
Чтобы это сделать нажмите F4 или вручную откройте терминал. В окне навигатора в терминале выберите раздел «Пользовательские Индикаторы«, найдите MyFirstIndicator и перетащите его на график цены.
Замечание: Ваш индикатор показывает волатильность рынка.

Постоянная ссылка

Препроцессор — это программа, обеспечивающая предварительную обработку кода для его подготовки к компиляции.
Например, если Вы используете директиву #include , это означает, что Вы говорите препроцессору включить содержимое файла «win32.h» в том месте, где Вы написали ключевое слово include. В MQL4 существуют 4 препроцессорные директивы:
1 — директива define
Директива define используется для задания значения константы. Константа очень похожа на переменную за тем исключением, что константе Вы придаёте значение только один раз и потом поменять его не можете.
Например:
Как Вы можете заметить в приведённом примере нет символа присваивания «=», а есть только пробел между именем константы (my_constant) и её значением (100).
И также Вы должны были заметить, что строчка не закончилась точкой с звпятой — она закончилась символом перехода на новую строку.

Имена констант подчиняются тем же правилам, что и имена переменных (см. предыдущий пост), например нельзя начинать имя константы с цифры, и его длина не должна превышать 31 символ.
Значение константы может быть любым.
Препроцессор просто заменит Вашу константу на её значение везде, где повстречает её в коде. Да именно так —заменит одни символы (имя константы) на другие (её значение). И всё это произойдёт до компиляции, поэтому компилятор даже не заметит, что у Вас была какая-то константа.
Так что, Вашу константу можно применить, например так:
2 — директива property

В MQL4 существуют заранее подготовленные переменные, называемые «Управляющие Компляцией», значения которых можно изменять для своей программы.
Для этого используется директива property — она говорит препроцессору, как настроить Ваш исполняемый файл *.ex4 .
Пример:
3 — директива include
Использование директивы include равносильно копированию всего содержимого подключаемого файла к себе в программу, в то место, где стоит эта директива. Ctrl+C -> Ctrl+V — только за Вас это делает препроцессор.
Пример:
В этом примере Вы говорите препроцессору, открыть файл «win32.h«, прочитать всё его содержимое и скопировать в то место, где стоит директива include.

Внимание: Есть два различных способа указания пути к файлу.
- Можно указать имя файла в угольных скобках — тогда препроцессор будет искать его в директории по умолчанию (он знает, где она находится).
- Можно указать имя файла в кавычках «win32.h» — тогда препроцессор будет искать этот файл в текущей директории — в той, где будет лежать Ваш код. Если Ваш код и искомый файл лежат в разных местах, то можно указать полный путь к файлу — это тоже делается с помощью кавычек: «F:My_folderMy_include_filesHello.h» .

Директиву include можно вставить в любую часть кода, но обычно это делается в самом начале.

Подсказка: Хорошей практикой является размещение часто употребляемого Вами кода в отдельном файле, для его дальнейшего подключения в свои программы.
(просто совет).

4 — директива import

Это как директива include, но есть различия.
Директива import используется только для подключения исполняемых файлов MQL4 (*.ex4) и динамических библиотек (*.dll), чтобы импортировать их функции в Вашу программу.
Например:

 Код:

#import "user32.dll"

int MessageBoxA(int hWnd,string lpText,string lpCaption,

int uType);

int MessageBoxExA(int hWnd,string lpText,string lpCaption,

int uType,int wLanguageId);

#import "melib.ex4"

#import "gdi32.dll"

int GetDC(int hWnd);

int ReleaseDC(int hWnd,int hDC);

#import

Когда Вы импортируете функции из файла *.ex4 нет необходимости их объявлять.
Когда Вы импортируете функции из файла *.dll необходимо объявлять функции, чтобы они были готовы к использованию.
Пример объявления функции:

 Код:

int MessageBoxA(int hWnd,string lpText,string lpCaption, int uType);

Импорт функций начинается со строчки #include «имя файла» (или в угольных скобках).
Импорт йункций заканчивается строчкой #include .

Как говорит один знакомый информатик: «препроцессор помогает избежать работы обезьянкой». Этим всё сказано!!!

Постоянная ссылка

Программа, которую Вы пишите на MQL4 (или на любых других языках) выполняется сверху вниз (я имею ввиду откомплированный файл). Оператор за оператором.
Оператор — это строчка кода, которая говорит компьютеру что-либо сделать.
Например:

Точка с запятой является очень важной частью оператора, но обычно очень легко забывается, потому является причиной 90% всех ошибок.
Принцип выполнение кода сверху вниз имеет исключения — это циклы и условия.
Программа, которую Вы пишите, может, как человек, принимать решения в ответ на изменение обстоятельств. В таких случаях управление перепрыгивает из одной части программы в другую её часть.
Операторы, которые вызывают такие прыжки называются Операторами Контроля (контроллерами).
Контроллеры состоят из циклов и условий.


Циклы заставляют раздел программы выполнятся определённое число раз.
Такое повторение продолжается пока какое-то условие явлется истинным (true) и прекращается как только условие становится ложным (false).
Когда цикл завершается контроль переходит следующему за циклом оператору.

В MQL4 существует два вида циклов:

1 — цикл for

Цикл for считается самым простым циклом, поскольку все его параметры собраны в одном месте.
Цикл for выполняет определённый раздел кода фиксированное число раз.
Например:

Как это работает?
Оператор состоит из ключевого слова for, за этим следуют круглые скобки, в которых указаны 3 выражения, разделённые точками с запятыми:


Эти три выражения — это: выражение инициализации, выражение проверки и выражение инкремента.

j = 0 — выражение инициализации
j < 15 — выражение проверки
j++ — выражение инкремента

Тело цикла — это код, который будет выполняться:

Print(j); — тело цикла.

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

Замечание: сразу после выражения for(…;…;…) точка с запятой НЕ ставится, т.к. это выражение + идущее после него тело цикла считаются единым оператором.
Кстати, в этом заключается очень распространённая ошибка — оператор ; (просто точка с запятой) называется пустым оператором (он не говорит компьютеру что-либо делать), поэтому цикл for(…;…;…); имеет пустое тело. В основном это не то, чего мы хотим.

Выражение инициализации выполняется только один раз — когда цикл запускается. И его задача — снабдить переменную цикла начальным значением (в нашем случае — нулём).
Вы можете объявить переменную цикла вне самого цикла, как в нашем примере:

Или Вы можете объявить её прямо внутри скобок цикла:

Две предыдущие строчки кода эквиваленты за тем исключением, что области видимости (об этом в уроке про переменные) переменной цикла в обоих случаях разные. Во втором случае переменная считается объявленной только внутри самого цикла.

В цикл for можно вставить больше одного выражения инициализации, разделив их запятой:


Выражение проверки — это выражение, которое построено на операциях сравнения и логических операциях (см. пред. урок).
Проверка истинности выражения происходит после каждого прохождения цикла. Цикл продолжается, если выражение истинно, цикл завершается, если выражение ложно.
В нашем примере тело цикла будет продолжать печатать i ( Print(i); ), пока условие j<15 верно. j пробежит значения 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14, затем j станет = 15 и цикл остановится. Контроль перейдёт оператору, следующему за циклом.


Выражение инкремента только так называется. Его задача — изменять переменную цикла. В нашем случае оно увеличивает j на 1.
Например, в следующем примере распечатаются числа 15,14,13,12,11,10,9,8,7,6,5,4,3,2,1:

Выражение инкремента выполняется самым последним в списке шагов цикла.
Как и в выражении инициализации, в выражении инкремента можно использовать более одного выражения, разделив их запятой:

Но выражение проверки может быть только одно.


Во всех предыдущих примерах в качестве тела цикла мы использовали толко один оператор. В большенстве случаев этого недостаточно.
В тело цикла можно записывать много операторов, если их все взять в фигурные скобки:

В этом коде в теле цикла содержится два оператора. Программа будет выполнять 1й оператор, а за ним 2й при каждом прохождении цикла.
Не забывайте ставить точку с запятой в конце каждого оператора.


Если при выполнении цикла for (или цикла while, или оператора switch) встречается оператор break;, то цикл терминируется, а контроль переходит оператору, следующему за циклом. PS: break — это ключевое слово.

Например:

В этом примере цикл будет нормально выполняться пока i не достигнет значения 10. Как только это произойдёт, операторbreak; остановит цикл. В результате, на экран распечатаются: 0,1,2,3,4,5,6,7,8,9.


Оператор break; останавливает цикл, а оператор continue; переводит цикл на следующий шаг, игнорируя оставшиеся операторы тела цикла.
Например:

В этом примере цикл будет нормально выполняться пока i не достигнет значения 10. Как только это произойдёт, операторcontinue; переведёт цикл на следующий шаг, и i=10 НЕ распечатается. В результате, на экран распечатаются: 0,1,2,3,4,5,6,7,8,9,11,12,13,14.

Важно!

Часть или даже все управляющие выражения цикла for можно опускать.
Например:

Этот цикл равносилен циклу while, в котором выражение проверки всегда истинно.


2 — цикл while

Цикл for обычно используется, когда Вы знаете, сколько раз цикл должен быть пройден. А что делать, если это не так?
Для этого есть цикл while.
В цикле while, как и в цыкле for есть выражение проверки, но в нём нет выражений инициализации и инкремента.
Пример:

• Переменная цикла была объявлена и про инициализирована ДО цикла. В отличии от цикла for, внутри скобок этого делать нельзя.
• Формально i++ НЕ является выражением инкремента, но нам нужно чтобы что-то в цикле менялось, чтобы мы когда-нибудь из него выбрались.

Как же приведённый пример работает?
Оператор while содержит только выражение проверки, и он его проверяет после каждого прохождения цикла. Если оно истинно, цикл продолжится. Если оно ложно, цикл завершится и контроль перейдёт оператору, следующему за циклом.

В приведённом примере цикл будет выполняться пока i не станет равным 16. Как только это произойдёт, проверка условия i<15 вернёт false, и цикл завершится.
Я уже говорил, что цикл while похож на цикл for. Вот их сходства:

1. В обоих можно использовать операторы break; и continue; .
2. В обоих тело цикла может быть одиночным или составным. Во вотром случае операторы тела цикла нужно брать в фигурные скобки.
3. Аналогом for(;;) является while(true).


Мы уже поговорили про циклы. Теперь Вы знаете, что циклы — это один из двух способов изменить обычный порядок выполнения программы сверху вниз. Второй способ — это условия.
Условия могут провоцировать однократный прыжок в другую часть программы, в зависимости от значаения некоторого выражения.

1 — Оператор if

Оператор if является самым простым среди операторов условия.
Пример:

После if идут круглые скобки, в которых записывается выражение проверки (в данном случае x < 100). Если результат выражение проверки является истиной (true), то тело оператора if будет выполнено. В данном случае тело состоит из одного оператора — Print(«hi»); . А если результат выажения проверки является ложью (false), то тело оператора if НЕ выполняется, а контроль переходит оператору, следующему за телом if.
Несколько операторов в теле if

Точно, как и в циклах, тело оператора if может состоять из нескольких операторов, взятых в фигурные скобки.
Пример:
Обратите внимание на сумбол == и выражении проверки. Это одна из операций сравнения, которые Вы изучали в уроке 4 «Операции и Выражения».
Отсюда происходит очень много ошибок — когда Вы забываете символ ==, и вместо него используете символ операции присваивания =.


Циклы и условия можно вкладывать друг в друга.
Пример:
Заметьте, что тело цикла в данном примере НЕ нужно заключать в фигурные скобки, потому что оператор if и все операторы внутри его тела считаются как один оператор.

2 — Оператор if … else

Оператор if позволяет что-то сделать, если определённое условие выполняется. Допустим, мы хотим сделать что-то другое, если это условие не выполнено. Для этого есть оператор if … else. Он состоит из оператора if и его тела, после чего идёт ключевое слово else и его тело.
Пример:
Вложенные операторы if…else

Операторы if … else и оператор if можно как угодно вкладывать друг в друга.
Пример:
Есть опастность, связанная с вложенными операторами if … else. По невнимательности Вы можете случайно связать какой-то else не с тем if.
Чтобы избежать подобных ошибок, можно сделать одно из двух:

1 — всегда брать пары if … else в фигурные скобки.
Вот так:
2 — Если Вам не подходит 1й вариант (слишком много этих if … else, или Вам просто лень), то просто следуйте правилусвязывать else с ближайшим if.

3 — Оператор switch

Если у Вас есть большое дерево условий, и все условия зависят от одного параметра, то можно применить оператор switch.
Пример:
После ключевого слова switch идут круглые скобки. Внутри этих скобок находится switch-константа. Внктри фигурных собок находятся case-константы — это проверямые условия switch-константы. Они записываются в виде case <значение>: <что делать>. <Значение> может быть integer, character или неизменным выражением. Неизменность выражения означает, что оно не зависит от переменных. Например, выражение X+Y не является неизменным.

Как же работает указанный пример?
Оператор switch сравнивает switch-константу поочерёдно со всеми case-константами.
В случае x==’A’ программа напечает «CASE A» и оператор break; прервёт оператор switch. Контроль передастся за пределы блока switch.
В случае x==’B’ или x==’C’, программа напечатает «CASE B or C». Это потому что нет оператора break; в case ‘B’: .
В случае x!= ни одной из case-констант, оператор switch выполнит блок default: и напечатает «NOT A, B jr C».

Добро пожаловать в мир функций языка MQL4.
Работа с функциями в любом языке состоит из двух этапов:
- изучение функций, что, порой, очень скучное занятие
- использование функций, что всегда является спасательной шлюпкой.


Функция очень похожа на мясорубку — вы кладёте в неё мясо, лук, специи и получаете фарш.
Мясо, лук и специи называются параметрами функции (входными параметрами функции), фарш — возвращаемое значение. А механизм мясорубки — тело функции.
Есть только одно различие между функциями и Вашей мясорубкой: некоторые функции возвращают НИЧЕГО (в MQL4 ничего называется словом void).
Пример:
 return (a*b + c); // фарш на выход - функция возвращает некоторое значение

 }
Как Вы видите выше, функция начинается с типа возвращаемого значения «double», за ним следует имя функции, после которого идут круглые скобки.
Внутрь скобок Вы кладёте мясо, лук и специи, точнее параметры функции.
В данном случае — три параметра: double a, double b, double c.
Затем идёт тело функции, которое заключено в фигурные скобки.
В данном примере, тело функции выполнит операцию (a*b + c).
Ключевое слово return ответственно за возвращение итого результата.


Оператор return (); завершает работу функции (как break; завершает работу цикла), и передаёт контоль в точку вызова функции (об этом скоро).
Оператор return (); может содержать выражение в своих скобках, как в нашем примере. Это означает, что надо завершить работу функции и вернуть результат вычисление этого выражения.
Или оператор return (); может не содержать выражения в своих скобках. Тогда его единственная задача — завершить работу функции.
Внимание: не все функции используют оператор return (); Особенно, если возвращаемого значения нет, как в следующем примере:
Эта функция не вернёт никакого значения, но она напечатает параметр s, который Вы ей предоставите. Чтобы показать, что функция ничего не возвращает, используется «void» в качестве её возвращаемого значения.
В некоторых языках программирования такие функции называются «методам», но в MQL4 они всё равно функции.


Теперь, я надеюсь, мы понимаем, что такое функция. Как же использовать функции в Вашей программе?
Есть ещё один шаг, который нужно для этого сделать.
Этот шаг называется вызовом функции (её использованием).

Допустим, у Вас есть функция, котороая возвращает сумму двух integer.
Вот она:
Вы хотите ей воспользоваться в своей программе.
Делается это так:
В этом примере на экран распечатается 25. Магия! Но как компьютер узнал, что печатать?
Магической является строчка int sum = collect(a,B); Здесь Вы объявили переменную sum, чтобы в неё положить возвращаемое значение, а затем дали функции на вход два параметра (a,b).

Вы просто-напросто вызвали функцию.

Когда MQL4 видит имя функции в Вашей программе, он берёт Ваши параметры и идёт к функции, после чего он возвращается с результатом и кладёт его на то же место.
На самом деле, происходит следующее: в процессе компиляции MQL4 заменяет строчку с вызовом функции в вашей программе целиком телом самой функции (с учётом Ваших параметров). Причём вместо оператора return(); MQL4 производит присваивание возвращаемого им значения в родготовленную Вами переменную.


В тело одной функции можно вкладывать другие функции. Это потому что строчка вызова обрабатывается, как оператор (это и есть оператор).
Пример:
В этом примере мы вызвали функцию collect внутри функции print_collection и распечатали результат. void означает, что возвращаемого значения нет (ещё помните?).


В MQL4 любая программа начинает своё выполнение с функции «init()» (initialize) и она срабатывает, когда Вы перетаскиваете программу (советника или индикатор) на график MetaTrader или если Вы поменяете валюту или период графика. Задача этой функции заключается в инициализации основных переменных, необходимых для работы Вашей программы. (Больще об инициализации переменных Вы узнаете далее).

Когда Ваша программа заканчивает свою работу, или Вы закрываете окно графика, или меняете валюту или период графика, или закрываете терминал, срабатывает функция «deinit()» (de-initialize).

Третья функция (самая важная) «start()» срабатывает каждый раз, когда приходят новые котировки. 90% своей программистской жизни Вы проводите внутри этой функции.

Мы больше узнаем об этих функциях, когда будем писать советник или индикатор


Зачем нужны переменные?

Как я уже говорил ранее, переменные — это всего лишь имена, которые привязаны к кускам памяти, где храняться соответствующие данные.
Чтобы было легче понимать, что происходит, представьте себе, что память — это набор коробок различных размеров. Размер коробки — это эквивалент количества бит, требуемого для хранения данного типа.

• Чтобы использовать коробку для хранения данных, необходимо присвоить ей имя. Этот процесс называется объявлением.
• В процессе объявления Вы используете слово, чтобы объяснить компьютеру какого размера коробка Вам нужна. Это слово называется ключевым.
• Лучше дать имя коробке такое, чтобы потом было легко понять, что в ней лежит.
• Данные кладутся в коробку путём присвоения данных коробке.
• Если объявление и присвоение данных происходит в одной строчке, то такой процесс называется инициализацией.

Когда мы создаём переменную, мы говорим компьютеру, что мы хотим, чтобы он присвоил часть памяти определённого размера (в битах) нашей переменной. Поскольку хранение числа, буквы или большого числа занимает разный объём памяти, компьютер спросит, что Вы хотите хранить в этой памяти, и каков размер данных. Для этого и нужны типы данных.

Например, если мы дадим компьютеру следующую строчку кода:
то мы говорим компьютеру, что хотим, чтобы он выделил блок памяти длиной 4 байта под нащу переменную «MyVariable».

В этом примере:

int — это ключевоу слово

int — тип данных integer

int — объявление

MyVariable — имя переменной

=0 — инициализация

О переменных мы узнаем больше далее.

В MQL4 присутствубт следующие типы данных:

• Integer (int)
• Boolean (bool)
• Character (Char)
• String (String)
• Floating-point number (double)
• Color (color)
• Datetime (datetime)

Я скопировал для Вас предыдущие строки из поста про типы данных. Теперь Вы вспомнили, что такое переменные в MQL4  — давайте посмотрим, как их надо объявлять:


Объявить переменную означает представить её миру и указать её тип. Для этого используются ключевые слова, которые мы упоминали в посте про типы данных (int, double, char, bool, string, color и datetime) и имя, которое Вы выбрали для своей переменной.
Например:
Здесь Вы объявили переменную под именем MyVariable, которая имеет тип integer. До строчки объявления ‘слово’MyVariable в коде использовать нельзя. Если Вы попробуете это сделать, то компилятор MQL4 будет жаловаться и выдаст такую ощибку: ‘MyVaraible’ — variable not defined. 1 error(s), 0 warning(s).

Итак, инициализация означает присвоение значения переменной, например: MyVaraible=0; Инициализацию можно производить в той же строчке, что и объявление: int MyVariable=0;
А можно объявить переменную в одном месте, а инициализацию производить совершенно в другом:
Но помните, что объявление всегда идёт ДО инициализации.

Есть два типа зон видимости переменной — локальная и глобальная.

1 — Локальная зона видимости

Локальные переменные не видны вне того мира, где они были объявлены. Границы ‘мира’ определяются ближайшей парой фигурных скобок {}. Сверху мир ограничен скобкой {, а снизу — скобкой }. Например, переменные, объявленные внутри функции, локальны для тела этой функции. Переменные, объявленные внутри цикла или услови локальны для этого цикла или условия, и они НЕ видны и НЕ могут быть использованы вне этого цикла или условия.
Например:
В приведённом примере переменные a,b,c и d являются локальными и могут быть использованы только внутри тела этой функции.

2 — Глобальная зона видимости

Глобальные переменные — это переменные, объявленные вне всех фигурных скобок. Они видны и могут быть использованы в любой части Вашей программы.
Например:
Здесь глобальная переменная Global_Variable объявлена вне функции (на уровне обявления функций), поэтому она видна всем функциям Вашей программы.
Глобальные переменные автоматически выставляются на нуль, если Вы их не проинициализировали при объявлении.


Ключевое слово «extern» используется для объявления переменных специального вида (не типа, а вида). Переменные такого вида используются для хранения входных данных программы, которые Вы можете ввести в окошке настроек Вашего советника или индикатора.
Например:
В этом примере переменная Indicator_color была объявлена, как extern, которую Вы увидите, когда прикрепите индикатор к графику в терминале, и которую можно менять в окошке настроек.
Здесь переменные Period, Shift, MA_method, Apply_to и Style — переменные, объявленные с использованием ключевого слова «extern«. Поэтому они появляются в окошке настроек.
Если Вы хотите, чтобы пользователь мог изменять какую-либо переменную, сделайте её extern-переменной

Постоянная ссылка

Так как брокерские дома оперирую огромными суммами напрямую с Вами они работать не будут, но существуют компании, которые готовы работать с каждым и с любыми капиталами – их в свою очередь называют Дилинговыми центрами или ДЦ.

Постоянная ссылка