Основы языка 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, а также ознакомимся с другими встроенными функциями, которые предоставляют огромные возможности для программирования.
|