Основы языка MQL 4. Первое знакомство.

Часть 2

Массивы

Не пугайтесь. Это очень просто. Смотрите. Допустим, вы хотите запомнить пять цен. Как можно поступить? Ну, можно вот так:

double price1 = 1.2341; 
double price2 = 1.2321; 
double price3 = 1.2361; 
double price4 = 1.2411; 
double price5 = 1.2301;

У нас получается пять переменных, которые имеют один тип данных и описывают один и тот же параметр - цену. Но можно поступить иначе, используя массив. Массив - это всего лишь серия переменных, которые отличаются между собой индексами, но имеют одно общее название. Посмотрите, как нужно объявлять массив из пяти элементов:
 

double price[5];

Общая форма:
 

(тип массива) (название массива) [количество элементов];
 

В нашем случае: тип массива - double, название - price, количество элементов - 5. Давайте посмотрим, как можно обратиться к элементам массива:
 

double price[5]; // объявляем массив из 5 элементов 
 
price[0] = 1.2341; // обращаемся к первому элементу массива и 
 // присваиваем ему цену. Обратите внимание 
 // на то, что индекс первого элемента 
 // начинается с 0. Это важная особенность,
 // к которой нужно привыкнуть. 
 
price[1] = 1.2321; // обращаемся ко второму элементу 
price[2] = 1.2361; // и так далее 
price[3] = 1.2411; 
price[4] = 1.2301;

С элементами массива можно проделывать любые операции, как и с обычными переменными. Собственно, элементы массива - и есть обычные переменные:
 

double price[2]; 
price[0] = 1.2234; 
price[1] = 1.2421; 
MessageBox("Middle price is " + (price[0] + 
 price[1]) / 2.0,"middle price");

При объявлении массива можно также присвоить всем элементам начальные значения:
 

double price[2] = {1.2234, 1.2421};

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

double price[] = {1.2234, 1.2421};

Это всё, безусловно, очень хорошо, но... К сожалению, бесполезно. Нам нужно как-то добраться до реальных данных! Например, текущих цен, времени, количества свободных денег и так далее.

Встроенные или предопределённые массивы и переменные

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

High[0]; // обращаемся к последней максимальной цене, 
 // которой достиг бар на текущем таймфрейме 
 // и текущей валютной паре. Валютная пара и 
 // таймфрейм зависят от графика, на котором 
 // вы запустили скрипт. Это очень важно 
 // запомнить!
Low[0]; // минимальная цена последнего бара на 
 // текущем графике. 
Volume[0]; // объём последнего бара на текущем графике.

Чтобы окончательно разобраться в предопределённых массивах и индексах, посмотрите на это:
 

Как видите, индекс (номер) последнего бара - 0, предпоследнего - 1 и так далее.
Также существуют предопределённые обычные переменные. Например, Bars показывает, сколько баров загружено на текущем графике. То есть это самая обычная переменная, но её объявили до вас и вне вашего скрипта. Эта переменная существует всегда, как и любые другие предопределённые массивы и переменные.

Циклы

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

double AveragePrice = 0.0; 
AveragePrice += High[0];
AveragePrice += High[1]; 
AveragePrice += High[2]; 
AveragePrice += High[3]; 
AveragePrice += High[4]; // ... и так далее
AveragePrice /= Bars;

Скажу вам одно: это может сработать, но это - очень глупо. Для таких целей существуют циклы. Обратите внимание, что все операции абсолютно одинаковы, лишь индекс изменяется от 0 до значения переменной Bars-1. Было бы намного удобнее каким-то образом определить счётчик и с его помошью обращаться к элементам массива. Вот как можно решить эту же задачу, используя циклы:

double AveragePrice = 0.0; 
for(int a = 0; a < Bars; a++)
{ 
 AveragePrice += High[a];
}

Рассмотрим каждую строку:
 

double AveragePrice = 0.0; // тут всё и так понятно
// а это самый настоящий цикл.
for(int a = 0; a < Bars; a++)

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

for(объявление счетчика; условие выполнения цикла; 
 изменение счетчика)
 {
 // между фигурными скобками размещается исходный код,
 // который будет повторяться
 }

Рассмотрим каждую стадию объявления цикла более детально.

Объявление счетчика: используется тип int для счётчика. Название переменной-счётчика не имеет никакого значения. Также обязательно производите инициализацию начального значения, например, нулём.

Условие выполнения цикла: тут всё очень просто. Здесь определяется условие, и если оно истинно, то цикл продолжается. Иначе - цикл заканчивается. Например, в нашем случае:
 

a < Bars

Видно, что пока переменная-счётчик а будет меньше, чем переменная Bars, то цикл будет выполняться дальше. Допустим, переменная Bars=10, тогда с каждым проходом по телу цикла переменная а будет увеличиваться на 1, пока не достигнет 10, после чего цикл прекратится.

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

// этот цикл:
// double AveragePrice=0.0;
//
// for(int a=0;a>
// {
// AveragePrice+=High[a];
// }
//
// будет будет выполнен следующим образом:
//
 
double AveragePrice=0.0;
 
int a=0;
 
AveragePrice+=High[a];
a++; // теперь а=1, предположим, что Bars=3.
 // Тогда, так как Bars больше чем а, 
 // то цикл продолжается
 
AveragePrice+=High[a];
a++; // а=2
 
AveragePrice+=High[a];
а++; // a=3
 
// но так как условие уже не выполняется, то цикл 
// прекращается, ведь теперь и а, и Bars равны трём.

Теперь вы должны понимать, как работает цикл. Но нужно знать ещё несколько моментов.

Условие выполнения цикла может быть другим. Например, таким:
 

a>10 // цикл выполняется, пока a больше 10
a!=10 // цикл выполняется, пока а не равно 10
a==20 // пока а равно 20
a>=2 // пока а больше или равно 2
a<=30 // пока а меньше или равно 30

Изменение счётчика может производиться и по-другому. Например, вам необязательно увеличивать его каждый раз на 1. Вы можете поступить иначе:
 

a-- // счётчик будет каждый раз уменьшаться на 1 
a += 2 // счётчик будет каждый раз увеличиваться на 2

Кроме того, вы можете разместить изменение счётчика внутри тела цикла. Например, так:
 

for(int a=0; a<Bars;)
 {
 AveragePrice+=High[a];
 
 a++; // счётчик изменяется внутри тела цикла
 }

Аналогично - необязательно объявлять переменную-счётчик в цикле. Можно сделать иначе:
 

int a = 0;
 
for(;a < Bars;)
 {
 AveragePrice += High[a];
 
 a++; // счётчик изменяется внутри тела цикла
 }

Если тело цикла содержит всего один оператор, например, вот так:
 

for(int a = 0; a < Bars; a++)
 {
 AveragePrice += High[a];
 }

то фигурные скобки писать необязательно:
 

for(int a = 0; a < Bars; a++)
 AveragePrice += High[a];

Пока это - всё, что касается циклов. Есть и другие виды циклов, но о них мы поговорим на следующем уроке. Сейчас вы должны уяснить, когда нужно использовать циклы, и запомнить их синтаксис. Попробуйте самостоятельно написать несколько циклов, которые бы выводили значения счётчика функцией MessageBox(). Попробуйте написать бесконечный цикл и посмотрите, что произойдет, если его запустить.

Условия

Осталась ещё одна важная вещь, которую вы будете постоянно использовать, - условия. В нашей жизни много условий и действий, которые следуют за этими условиями. Мы очень часто даже мыслим условными предложениями. Например: "Если у меня будет достаточно времени, я успею прочитать эту книгу. Если нет, то, пожалуй, лучше полистать свежий журнал. " Вы и сами можете придумать сотни подобных условий и действий. Но как записать их на MQL4? Вот пример:

// конечно, писать условия нужно на языке MQL4
if( у меня будет достаточно времени ) 
 { 
 // а тут мы размещаем любые действия, команды на MQL4
 то дочитаю эту книжечку; 
 }
// если первое условие не выполняется, то выполняется 
// второе условие
else 
 {
 полистаю свежий журнальчик; // код
 }

Теперь вы должны понимать синтаксис условий. Давайте посмотрим на условия, полностью написанные на языке MQL4:

int a = 10;
int b = 0;
 
if(a > 10 )
 {
 b = 1;
 }
else
 {
 b = 2;
 }
 
MessageBox("b=" + b,".");

Всё довольно-таки просто. Чему равно b после выполнения? Конечно, b = 2, потому что условие a > 10 не выполняется. Это элементарно. Кстати, использовать ключевое слово else (иначе) необязательно:

int a = 10;
int b = 0;
 
if(a > 10)
 {
 b = 1;
 }

В таком случае, если условие не выполняется, блок кода, который следует после условия между фигурными скобками, пропускается. В нашем случае после выполнения b = 0. Также следует обратить внимание на то, как строятся условия. Нам известно, что разные типы переменных могут принимать разные значения, например:

• int - целые значения (1, 60, 772);
• double - с плавающей запятой (1.0021, 0.221);
• string - только строки ("Word", "Some text.");
• bool - только правда или неправда (true, false).

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

int Integer=10;
double Double=1.0;
string String="JustWord";
bool Bool=true;
 
if(Integer<10) // условие построено правильно
{
 MessageBox("It works!","Really!");
}
 
if(Double!=1.0) // условие построено правильно
{
 MessageBox("works!","Simple!");
}
 
if(String==10) // а вот это уже полный бред!! 
 // Мы определили переменную 
 //String с типом string, а 10 это int
{
 MessageBox("Wrong type","u can't c this");
}
 
if(String!="Word") // другое дело
{
 // ...
}
 
if(Bool==true) // правильно
{
 // ...
}

Обратите внимание, что мы производим сравнения при помощи условных операторов (==, !=, >, <, >=, <=). Для типов string и bool используйте только такие операторы сравнения как == и !=.

Теперь вы должны ознакомиться с таким понятием, как вложенность. Да, вы можете использовать условия в циклах, а циклы в условиях; вы можете использовать в условиях другие условия и так далее. Например:

int a=0;
double b=0.0;
bool e;
 
if(a==0)
{
 for(int c=0;c<Bars;c++)
 {
 b+=High[c];
 }
 
 if(b>500.0)
 {
 e=true;
 }
 else
 {
 e=false;
 }
}

Следующий пример показывает ещё один способ использования условий:

int a=0;
int result;
 
if(a==0)
{
 result=1;
}
else if(a==1)
{
 result=2;
}
else if(a==2)
{
 result=3;
}
else
{
 result=4;
}

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

if(a==1)
{ 
 b=2;
}
 
// а можно и так:
 
if(a==1)
 b=2;

Сложные условия

Часто одного условия бывает маловато. Приходится сравнивать много параметров, и в таком случае без сложных условий не обойтись. Например, если у меня будет достаточно времени и терпения, я выучу язык MQL4. Это можно записать в виде кода так:

if((достаточно времени) && (достаточно терпения))
{
 я выучу язык MQL 4;
}

То есть сложное условие сначала нужно разбить на простые условия, заключить их в скобки, а потом между ними поставить && (логическое И) или || (логическое ИЛИ). Если нужно, чтобы оба условия были истинны, тогда используем && (И). Если нужно, чтобы истинным было или первое, или второе условие, то используем || (ИЛИ). Вот настоящий пример:

int a=10;
int b=20;
 
if((a>5) && (b<50))
 MessageBox("Its works!","Yes");

Кроме того, вы можете вкладывать и объединять сколько угодно условий:

int a=10;
int b=20;
 
if ( ((a>5) || (a<15)) && ( b==20))
 MessageBox("It works, too!","Yes");

Всё вместе

Используя вместе сложные и простые условия, а также циклы, вы можете написать очень сложный код. Практически любой алгоритм можно описать, используя эти незамысловатые структуры языка MQL4. Если вы поймете, как пишутся и работают эти простые вещи, вы поймёте половину из того, что из себя представляет MQL4 или любой другой язык программирования! Это действительно очень просто! Всё, что вам нужно, - это практика. Постарайтесь написать как можно больше скриптов, чтобы запомнить синтаксис языка и набраться опыта. Кроме того, просмотрите примеры, которые размещены в прикреплённом файле examples.mq4 и постарайтесь разобраться в них.

Другие предопределённые переменные и массивы

Вам уже известны массивы High[], Low[], Volume[] и переменная Bars. Ниже приведены еще некоторые полезные переменные:

double Open[] // массив цен открытия баров текущего 
 // графика
double Close[] // массив цен закрытия баров текущего 
 // графика
 
double Bid // последняя известная цена покупки на 
 // текущей валютной паре
double Ask // последняя известная цена продажи на 
 // текущей валютной паре

Заключение

Итак, вы узнали много нового. Уверен, что в вашей голове сейчас полный беспорядок. Перечитывайте текст, запоминайте, практикуйтесь и вникайте в суть. Обещаю, скоро всё станет на свои места. То, что описано в этой статье, - основа всего языка MQL4. Чем лучше вы освоите этот материал, тем проще вам будет учиться дальше. Скажу больше - учиться дальше будет намного легче, так как изложенный здесь материал - это самая трудная часть. В следующих статьях мы изучим различные особенности языка MQL4, а также ознакомимся с другими встроенными функциями, которые предоставляют огромные возможности для программирования.