Справочник по языку программирования MQL5

Подождите немного. Документ загружается.

Основы языка

struct str1

{

double d;

};

struct str2

{

long l;

};

//--- начнем

str1 s1;

str2 s2;

//---

s1.d=MathArcsin(2.0); // получим недействительное число -1.#IND

s2=s1;

printf("1. %f %I64X",s1.d,s2.l);

//---

s2.l=0xFFFF000000000000; // недействительное число -1.#QNAN

s1=s2;

printf("2. %f %I64X",s1.d,s2.l);

//---

s2.l=0x7FF7000000000000; // наиобльшее нечисло SNaN

s1=s2;

printf("3. %f %I64X",s1.d,s2.l);

//---

s2.l=0x7FF8000000000000; // наименьшее нечисло QNaN

s1=s2;

printf("4. %f %I64X",s1.d,s2.l);

//---

s2.l=0x7FFF000000000000; // наибольшее нечисло QNaN

s1=s2;

printf("5. %f %I64X",s1.d,s2.l);

//---

s2.l=0x7FF0000000000000; // плюс бесконечность 1.#INF и наименьшее нечисло SNaN

s1=s2;

printf("6. %f %I64X",s1.d,s2.l);

//---

s2.l=0xFFF0000000000000; // минус бесконечность -1.#INF

s1=s2;

printf("7. %f %I64X",s1.d,s2.l);

//---

s2.l=0x8000000000000000; // отрицательный ноль -0.0

s1=s2;

printf("8. %f %I64X",s1.d,s2.l);

//---

s2.l=0x3FE0000000000000; // 0.5

s1=s2;

printf("9. %f %I64X",s1.d,s2.l);

//---

s2.l=0x3FF0000000000000; // 1.0

s1=s2;

printf("10. %f %I64X",s1.d,s2.l);

//---

s2.l=0x7FEFFFFFFFFFFFFF; // наибольшее нормализованное число (MAX_DBL)

s1=s2;

printf("11. %.16e %I64X",s1.d,s2.l);

//---

s2.l=0x0010000000000000; // наименьшее положительное нормализованное (MIN_DBL)

s1=s2;

printf("12. %.16e %.16I64X",s1.d,s2.l);

//---

Основы языка

s1.d=0.7; // покажем, что число 0.7 – бесконечная дробь

s2=s1;

printf("13. %.16e %.16I64X",s1.d,s2.l);

1. -1.#IND00 FFF8000000000000

2. -1.#QNAN0 FFFF000000000000

3. 1.#SNAN0 7FF7000000000000

4. 1.#QNAN0 7FF8000000000000

5. 1.#QNAN0 7FFF000000000000

6. 1.#INF00 7FF0000000000000

7. -1.#INF00 FFF0000000000000

8. -0.000000 8000000000000000

9. 0.500000 3FE0000000000000

10. 1.000000 3FF0000000000000

11. 1.7976931348623157e+308 7FEFFFFFFFFFFFFF

12. 2.2250738585072014e-308 0010000000000000

13. 6.9999999999999996e-001 3FE6666666666666

Смотри также

DoubleToString, NormalizeDouble, Константы числовых типов

Основы языка

Тип string

Тип string предназначен для хранения текстовых строк. Текстовая строка представляет собой

последовательность символов в формате Unicode с завершающим нулем на конце. string-

переменной может быть назначена строковая константа. Строковая константа представляет собой

последовательность символов Unicode, заключенную в двойные кавычки: "Это строковая

константа".

Если необходимо ввести в строку двойную кавычку ("), то перед ней надо поставить символ

обратной косой черты (\). В строку могут быть введены любые специальные символьные

константы, перед которыми стоит символ обратной косой черты (\).

Примеры:

string svar="This is a character string";

string svar2=StringSubstr(svar,0,4);

Print("Символ копирайта\t\x00A9");

FileWrite(handle,"эта строка содержит символ перевода строки \n");

string MT5path="C:\\Program Files\\MetaTrader 5";

Длинные константные строки для удобства чтения исходного кода можно разбивать на части без

операции сложения. Эти части при компиляции автоматически соберутся в одну длинную строку:

//--- объявим длинную константную строку

string HTML_head="<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\""

" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n"

"<html xmlns=\"http://www.w3.org/1999/xhtml\">\n"

"<head>\n"

"<meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\" />\n"

"<title>Trade Operations Report</title>\n"

"</head>";

//--- выведем в журнал константную строку

Print(HTML_head);

}

Смотри также

Преобразование данных, Строковые функции, FileOpen, FileReadString, FileWriteString

Основы языка

Структуры и классы

Структуры

Структура является набором элементов произвольного типа (кроме типа void). Таким образом,

структура объединяет логически связанные данные разных типов.

Объявление структуры

Структурный тип данных определяется следующим описанием:

struct имя_структуры

{

описания_элементов

};

Имя структуры нельзя использовать в качестве идентификатора (имени переменной или функции).

Следует иметь ввиду, что в MQL5 элементы структуры следуют непосредственно друг за другом

без выравнивания. В языке C++ такое указание делается компилятору с помощью инструкции

#pragma pack(1)

Если требуется сделать иное выравнивание в структуре, необходимо использовать

вспомогательные члены-"заполнители" нужных размеров.

Пример:

struct trade_settings

{

uchar slippage; // значение допустимого проскальзывания -размер 1 байт

char reserved1; // 1 байт пропуска

short reserved2; // 2 байта пропуска

int reserved4; // еще 4 байта пропуска. Обеспечили выравнивание на границу 8 байт

double take; // значения цены фиксации прибыли

double stop; // значение цены защитного стопа

};

Такое описание выровненных структур необходимо только для передачи в импортированные dll-

функции.

Внимание: данный пример иллюстрирует неправильно спроектированные данные. Лучше было бы

сначала объявить данные take и stop большего размера типа double, а затем объявить член

slippage типа double. В этом случае внутреннее представление данных будет всегда одинаково

независимо от значения, указанного в #pragma pack().

Если структура содержит переменные типа string и/или объектдинамическогомассива, то

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

обнуление всех членов структуры типа string и правильная инициализация для объекта

динамического массива.

Простые структуры

Основы языка

Структуры, которые не содержат строки, объекты класса и объекты динамических массивов,

называются простыми структурами; переменные таких структур могут свободнокопироваться друг

в друга, даже если это разные структуры. Переменные простых структур, а также их массивы

можно передавать в качестве параметров в импортируемые из DLL функции.

Доступ к членам структуры

Имя структуры является новым типом данных и позволяет объявлять переменные этого типа.

Структура может быть объявлена только один раз в пределах проекта. Доступ к членам структур

производится при помощи операцииточка (.).

Пример:

struct trade_settings

{

double take; // значения цены фиксации прибыли

double stop; // значение цены защитного стопа

uchar slippage; // значение допустимого проскальзывания

};

//--- создали и проинициализировали переменную типа trade_settings

trade_settings my_set={0.0,0.0,5};

if (input_TP>0) my_set.take=input_TP;

Классы

Классы имеют ряд отличий от структур:

в объявлении используется ключевое слово class;

по умолчанию все члены класса имеют спецификатор доступа private, если не указано иное.

Члены-данные структуры по умолчанию имеют тип доступа public, если не указано иное;

объекты классов всегда имеют таблицу виртуальныхфункций, даже если в классе не объявлено

ни одной виртуальной функции. Структуры не могут иметь виртуальных функций;

к объектам класса можно применять оператор new, к структурам этот оператор применять

нельзя;

классы могут наследоваться только от классов, структуры могут наследоваться только от

структур.

Классы и структуры могут иметь явный конструктор и деструктор. В случае если явно определен

конструктор, инициализация переменной типа структуры или класса при помощи

инициализирующей последовательности невозможна.

Пример:

struct trade_settings

{

double take; // значения цены фиксации прибыли

double stop; // значение цены защитного стопа

uchar slippage; // значение допустимого проскальзывания

//--- конструктор

trade_settings() { take=0.0; stop=0.0; slippage=5; }

Основы языка

//--- деструктор

~trade_settings() { Print("Это конец"); }

};

//--- компилятор выдаст ошибку с сообщением о невозможности инициализации

trade_settings my_set={0.0,0.0,5};

Конструкторы и деструкторы

Конструктор - это специальная функция, которая вызывается автоматически при создании объекта

структуры или класса и обычно используется для инициализации членов класса. Далее мы будем

говорить только о классах, при этом все сказанное относится и к структурам, если не оговорено

иное. Имя конструктора должно совпадать с именем класса. Конструктор не имеет

возвращаемого типа (можно указать тип void).

Определенные члены класса – строки, динамическиемассивы и объекты, требующие

инициализации – в любом случае будут проинициализированы, независимо от наличия

конструктора.

Каждый класс может иметь несколько конструкторов, отличающихся по количеству параметров и

спискам инициализации. Конструктор, требующий указания параметров, называется

параметрическим конструктором.

Конструктор, не имеющий параметров, называется конструктором по умолчанию. Если в классе

не объявлен ни один конструктор, то компилятор сам создаст конструктор по умолчанию при

компиляции.

//+------------------------------------------------------------------+

//| класс для работы с датой |

//+------------------------------------------------------------------+

class MyDateClass

{

private:

int m_year; // год

int m_month; // месяц

int m_day; // день месяца

int m_hour; // час в сутках

int m_minute; // минуты

int m_second; // секунды

public:

//--- конструктор по умолчанию

MyDateClass(void);

//--- конструктор с параметрами

MyDateClass(int h,int m,int s);

};

Конструктор можно объявить в описании класса, а затем определить его тело. Например, вот так

могут быть определены два конструктора класса MyDateClass:

//+------------------------------------------------------------------+

Основы языка

//| конструктор по умолчанию |

//+------------------------------------------------------------------+

MyDateClass::MyDateClass(void)

{

//---

MqlDateTime mdt;

datetime t=TimeCurrent(mdt);

m_year=mdt.year;

m_month=mdt.mon;

m_day=mdt.day;

m_hour=mdt.hour;

m_minute=mdt.min;

m_second=mdt.sec;

Print(__FUNCTION__);

}

//+------------------------------------------------------------------+

//| конструктор с параметрами |

//+------------------------------------------------------------------+

MyDateClass::MyDateClass(int h,int m,int s)

{

MqlDateTime mdt;

datetime t=TimeCurrent(mdt);

m_year=mdt.year;

m_month=mdt.mon;

m_day=mdt.day;

m_hour=h;

m_minute=m;

m_second=s;

Print(__FUNCTION__);

}

В конструкторе по умолчанию заполняются все члены класса с помощью функции TimeCurrent(), в

конструкторе с параметрами заполняются только значения часа. Остальные члены класса

(m_year, m_month и m_day) будут проинициализированы автоматически текущей датой.

Конструктор по умолчанию имеет специальное назначение при инициализации массива объектов

своего класса. Конструктор, все параметры которого имеют значения по умолчанию, не является

компьютером по умолчанию. Покажем это на примере:

//+------------------------------------------------------------------+

//| класс с конструктором по умолчанию |

//+------------------------------------------------------------------+

class CFoo

{

datetime m_call_time; // время последнего обращения к объекту

public:

//--- конструктор с параметром, имюещем значение по умолчанию, не является конструктором по умолчанию

CFoo(datetime t=0){m_call_time=t;};

string ToString(){return(TimeToString(m_call_time,TIME_DATE|TIME_SECONDS));};

};

Основы языка

//+------------------------------------------------------------------+

//| Script program start function |

//+------------------------------------------------------------------+

void OnStart()

{

CFoo foo; // такой вариант использовать можно - будет вызван конструктор с параметрами по умолчанию

//--- допустимые ванианты создания объекта CFoo

CFoo foo1(TimeCurrent()); // первый способ автоматического создания объекта

CFoo foo2(); // второй способ автоматического создания объекта

CFoo foo3=TimeTradeServer(); // третий способ автоматического создания объекта

//--- допустимые ванианты создания указателей CFoo с помощью операттора new

CFoo *foo4=new CFoo();

CFoo *foo5=new CFoo(TimeTradeServer());

CFoo *foo6=GetPointer(foo5); // теперь foo5 и foo6 указывают на один и тот же объект

CFoo *foo7,*foo8;

foo7=new CFoo(TimeCurrent());

foo8=GetPointer(foo7); // foo7 и foo8 указывают на один и тот же объект

//CFoo foo_array[3]; // такой вариант использовать нельзя - конструктор по умолчанию не задан

//CFoo foo_dyn_array[]; // такой вариант использовать нельзя - конструктор по умолчанию не задан

//--- выведем значения m_call_time

Print("foo.m_call_time=",foo1.ToString());

Print("foo1.m_call_time=",foo1.ToString());

Print("foo2.m_call_time=",foo2.ToString());

Print("foo3.m_call_time=",foo3.ToString());

Print("foo4.m_call_time=",foo4.ToString());

Print("foo5.m_call_time=",foo5.ToString());

Print("foo6.m_call_time=",foo6.ToString());

Print("foo7.m_call_time=",foo7.ToString());

Print("foo8.m_call_time=",foo8.ToString());

//--- удалим динамически созданные объекты

delete foo4;

delete foo5;

delete foo7;

}

Если раскомментировать в этом примере строки

//CFoo foo_array[3]; // такой вариант использовать нельзя - конструктор по умолчанию не задан

или

//CFoo foo_dyn_array[]; // такой вариант использовать нельзя - конструктор по умолчанию не задан

то компилятор выдаст на них ошибку "default constructor is not defined".

Если класс имеет конструктор, объявленный пользователем, то конструктор по умолчанию не

будет сгенерирован компилятором. Это означает, что если в классе объявлен конструктор с

параметрами, но не объявлен конструктор по умолчанию, то нельзя объявлять массивы

объектов этого класса. Вот на таком скрипте компилятор сообщит об ошибке:

//+------------------------------------------------------------------+

Основы языка

//| класс без конструктора по умолчанию |

//+------------------------------------------------------------------+

class CFoo

{

string m_name;

public:

CFoo(string name) { m_name=name;}

};

//+------------------------------------------------------------------+

//| Script program start function |

//+------------------------------------------------------------------+

void OnStart()

{

//--- при компиляции получим ошибку "default constructor is not defined"

CFoo badFoo[5];

}

В данном примере класс CFoo имеет объявленный параметрический конструктор – в таких случаях

компилятор при компиляции не создает автоматически конструктор по умолчанию. В то же время

при объявлении массива объектов предполагается, что все объекты должны быть созданы и

инициализированы автоматически. При автоматической инициализации объекта требуется вызвать

конструктор по умолчанию, но так как конструктор по умолчанию явно не объявлен и не

сгенерирован автоматически компилятором, то создание такого объекта невозможно. Именно по

этой причине компилятор выдает ошибку еще на этапе компиляции.

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

Инициализаторы конструктора (специальные конструкции для инициализации) для членов

структуры или класса могут быть заданы в списке инициализации.

Список инициализации – это список инициализаторов, разделенных запятыми, который идет после

двоеточия за списком параметров конструктора и предшествует телу (идет перед открывающей

фигурной скобкой). Есть несколько требований:

списки инициализации можно использовать только в конструкторах;

в списке инициализации нельзя инициализировать члены родителей;

после списка инициализации должно идти определение (реализация) функции.

Покажем пример нескольких конструкторов для инициализации членов класса.

//+------------------------------------------------------------------+

//| класс для хранения фамилии и имени персонажа |

//+------------------------------------------------------------------+

class CPerson

{

string m_first_name; // имя

string m_second_name; // фамилия

public:

//--- пустой конструктор по умолчанию

CPerson() {Print(__FUNCTION__);};

//--- параметрический конструктор

CPerson(string full_name);

Основы языка

//--- конструктор со списком инициализации

CPerson(string surname,string name): m_second_name(surname), m_first_name(name) {};

void PrintName(){PrintFormat("Name=%s Surname=%s",m_first_name,m_second_name);};

};

//+------------------------------------------------------------------+

//| |

//+------------------------------------------------------------------+

CPerson::CPerson(string full_name)

{

int pos=StringFind(full_name," ");

if(pos>=0)

{

m_first_name=StringSubstr(full_name,0,pos);

m_second_name=StringSubstr(full_name,pos+1);

}

//+------------------------------------------------------------------+

//| Script program start function |

//+------------------------------------------------------------------+

void OnStart()

{

//--- получим ошибку "default constructor is not defined"

CPerson people[5];

CPerson Tom="Tom Sawyer"; // Том Сойер

CPerson Huck("Huckleberry","Finn"); // Гекльберри Финн

CPerson *Pooh = new CPerson("Whinnie","Pooh"); // Винни Пух

//--- выведем значения

Tom.PrintName();

Huck.PrintName();

Pooh.PrintName();

//--- удалим динамически созданный объект

delete Pooh;

}

В данном случае класс CPerson имеет три конструктора:

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

класса;

2. конструктор с одним параметром, который принимает в качестве параметра полное имя и

разделяет его на имя и фамилию по найденному пробелу;

3. конструктор с двумя параметрами, который содержит список инициализации. Инициализаторы –

m_second_name(surname) и m_first_name(name).

Обратите внимание, как инициализация с помощью списка заменила присваивание. Отдельные

члены должны быть инициализированы как:

член_класса (список выражений)

В списке инициализации члены могут идти в любом порядке, но при этом все члены класса будут