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

Основы языка

71

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

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

него будет инициализирован член m_second_name. Это необходимо учитывать в тех случаях,

когда инициализация одних членов класса зависит от значений в других членах класса.

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

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

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

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

списке инициализации.

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

//| базовый класс |

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

class CFoo

{

string m_name;

public:

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

CFoo(string name) : m_name(name) { Print(m_name);}

};

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

//| потомок класса CFoo |

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

class CBar : CFoo

{

CFoo m_member; // член класса является объектом предка

public:

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

CBar(): m_member(_Symbol), CFoo("CBAR") {Print(__FUNCTION__);}

};

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

//| Script program start function |

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

void OnStart()

{

CBar bar;

}

В приведенном примере при создании объекта bar будет вызван конструктор по умолчанию CBar(),

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

класса m_member.

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

объекта класса. Имя деструктора записывается как имя класса с тильдой (~). Строки,

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

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

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

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

Основы языка

72

слово virtual или нет.

Определение методов классов

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

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

после объявления метода.

Пример:

class CTetrisShape

{

protected:

int m_type;

int m_xpos;

int m_ypos;

int m_xsize;

int m_ysize;

int m_prev_turn;

int m_turn;

int m_right_border;

public:

void CTetrisShape();

void SetRightBorder(int border) { m_right_border=border; }

void SetYPos(int ypos) { m_ypos=ypos; }

void SetXPos(int xpos) { m_xpos=xpos; }

int GetYPos() { return(m_ypos); }

int GetXPos() { return(m_xpos); }

int GetYSize() { return(m_ysize); }

int GetXSize() { return(m_xsize); }

int GetType() { return(m_type); }

void Left() { m_xpos-=SHAPE_SIZE; }

void Right() { m_xpos+=SHAPE_SIZE; }

void Rotate() { m_prev_turn=m_turn; if(++m_turn>3) m_turn=0; }

virtual void Draw() { return; }

virtual bool CheckDown(int& pad_array[]);

virtual bool CheckLeft(int& side_row[]);

virtual bool CheckRight(int& side_row[]);

};

Функции с SetRightBorder(int border) по Draw() объявлены и определены прямо внутри класса

CTetrisShape.

Конструктор CTetrisShape() и методы CheckDown(int& pad_array[]), CheckLeft(int& side_row[]) и

CheckRight(int& side_row[]) только объявлены внутри класса, но пока не определены.

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

вне класса, используется операция разрешения контекста, в качестве контекста используется имя

класса.

Пример:

Основы языка

73

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

//| Конструктор базового класса |

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

void CTetrisShape::CTetrisShape()

{

m_type=0;

m_ypos=0;

m_xpos=0;

m_xsize=SHAPE_SIZE;

m_ysize=SHAPE_SIZE;

m_prev_turn=0;

m_turn=0;

m_right_border=0;

}

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

//| Проверка возможности двигаться вниз (для палки и куба) |

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

bool CTetrisShape::CheckDown(int& pad_array[])

{

int i,xsize=m_xsize/SHAPE_SIZE;

//---

for(i=0; i<xsize; i++)

{

if(m_ypos+m_ysize>=pad_array[i]) return(false);

}

//---

return(true);

}

Модификаторы доступа public, protected и private

При разработке нового класса рекомендуется ограничивать доступ к членам извне. Для этих

целей используются ключевые слова private или protected. Доступ в этом случае к сокрытым

данным может осуществляться только из функций-методов этого же класса. Если использовано

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

классов - наследников этого класса. Точно таким же образом может ограничиваться доступ и к

функциям-методам класса.

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

ключевое слово public.

Пример:

class CTetrisField

{

private:

int m_score; // счёт

int m_ypos; // текущее положение фигуры

int m_field[FIELD_HEIGHT][FIELD_WIDTH]; // матрица стакана

int m_rows[FIELD_HEIGHT]; // нумерация рядов стакана

int m_last_row; // последний свободный ряд

CTetrisShape *m_shape; // тетрисная фигура

bool m_bover; // игра закончена

public:

Основы языка

74

void CTetrisField() { m_shape=NULL; m_bover=false; }

void Init();

void Deinit();

void Down();

void Left();

void Right();

void Rotate();

void Drop();

private:

void NewShape();

void CheckAndDeleteRows();

void LabelOver();

};

Любые члены и методы класса, объявленные после спецификатора public: (и до следующего

спецификатора доступа), доступны при любом обращении программы к объекту этого класса. В

данном примере это следующие члены: функции CTetrisField(), Init(), Deinit(), Down(), Left(),

Right(), Rotate() и Drop().

Любые члены класса, объявленные после спецификатора доступа к элементам private: (и до

следующего спецификатора доступа), доступны только функциям-членам этого класса.

Спецификаторы доступа к элементам всегда заканчиваются двоеточием (:) и могут появляться в

определении класса много раз.

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

классах.

Смотри также

Объектно-ориентированное программирование

Основы языка

75

Объект динамического массива

Динамические массивы

Динамический массив представляет из себя структуру размером 40 байт. Допускается объявление

не более чем 4-мерного массива.

struct MqlArrayObject

{

ushort type; // закодированный тип данных

ushort flags; // флаги,определяющие статус массива

uint item_len; // размер одного элемента массива в байтах

int allocated; // фактический размер, распределенный для массива

int range0; // размер первого измерения (изначально равно 0)

int range1; // размер второго измерения, если есть. Иначе 0

int range2; // размер третьего измерения, если есть. Иначе 0

int range3; // размер четвертого измерения, если есть. Иначе 0

int reserved0; // данные для

int reserved1; // внутреннего

int reserved2; // использования

};

При объявлении динамического массива (массива с неуказанным значением в первой паре

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

(объект динамического массива) и обеспечивает код для правильной инициализации.

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

блока, в котором они объявлены.

Пример:

double matrix[][10][20]; // 3-мерный динамический массив

ArrayResize(matrix,5); // задали размер первого измерения

Статические массивы

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

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

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

связан с заранее распределенным статическим буфером (областью памяти для хранения

массива).

Создание объекта динамического массива обусловлено возможной необходимостью передавать

данный статический массив в качестве параметра в какую-либо функцию.

Примеры:

double stat_array[5]; // 1-мерный статический массив

some_function(stat_array);

...

Основы языка

76

bool some_function(double& array[])

{

if(ArrayResize(array,100)) return(false);

...

return(true);

}

Массивы в составе структур

При объявлении статического массива в качестве члена структуры объект динамического массива

не создается. Это сделано для совместимости структур данных, используемых в Windows API.

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

в MQL5-функции. В этом случае при передаче параметра будет создан временный объект

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

Смотри также

Операции с массивами, Инициализация переменных, Область видимости и время жизни

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

Основы языка

77

Приведение типов

Преобразование числовых типов

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

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

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

информации. Вместо типа char может выступать тип bool (оба занимают в памяти 1 байт), вместо

типа int можно использовать тип color (по 4 байта), а вместо типа long допустим тип datetime

(занимают по 8 байт). Четыре штриховые линии серого цвета, также со стрелками, означают

преобразования, при которых может произойти потеря точности. Например, количество цифр в

целом числе 123456789 (int) превышает количество цифр, которое может быть представлено

типом float.

int n=123456789;

float f=n; // содержимое f равно 1.234567892E8

Print("n = ",n," f = ",f);

// результат n= 123456789 f= 123456792.00000

Число, преобразованное в тип float, имеет тот же порядок, но несколько меньшую точность.

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

Преобразования между char и uchar, short и ushort, int и uint, long и ulong (имеются ввиду

преобразования в обе стороны), могут привести к потере информации.

В результате преобразования значения с плавающей точкой к целому типу дробная часть числа

всегда отбрасывается. Если нужно округлить число с плавающей точкой до ближайшего целого

числа (что во многих случаях является более полезным), необходимо использовать функцию

MathRound().

Пример:

//--- ускорение свободного падения

double g=9.8;

double round_g=(int)g;

double math_round_g=MathRound(g);

Print("round_g = ",round_g);

Print("math_round_g =",math_round_g);

/*

Результат:

round_g = 9

Основы языка

78

math_round_g = 10

*/

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

младшего типа преобразовывается к более старшему типу в соответствии с приоритетом,

указанным на схеме:

Типы данных char, uchar, short и ushort в операциях безусловно приводятся к типу int.

Примеры:

char c1=3;

//--- первый пример

double d2=c1/2+0.3;

Print("c1/2+0.3 = ",d2);

// Результат: c1/2+0.3 = 1.3

//--- второй пример

d2=c1/2.0+0.3;

Print("c1/2.0+0.3 = ",d2);

// Результат: c1/2.0+0.3 = 1.8

Вычисляемое выражение состоит из двух операций. В первом примере переменная c1 типа char

преобразуется ко временной переменной типа int, так как второй операнд в операции деления,

константа 2, имеет более старший тип int. В результате целочисленного деления 3/2 получается

значение 1, которое имеет тип int.

Во второй операции первого примера вторым операндом выступает константа 0.3, которая имеет

тип double, поэтому результат первой операции преобразуется во временную переменную типа

double со значением 1.0.

Во втором примере переменная c1 типа char преобразуется ко временной переменной типа double,

так как второй операнд в операции деления, константа 2.0, имеет тип double; дальнейших

преобразований не производится.

Приведение числовых типов

В выражениях языка MQL5 можно использовать как явное, так и неявное приведение типов.

Явное преобразование типов записывается следующим образом:

var_1 = (тип)var_2;

В качестве переменной var_2 может быть выражение или результат выполнения функции.

Допускается также функциональная запись явного приведения типов:

var_1 = тип(var_2);

Основы языка

79

Рассмотрим явное преобразование на основании первого примера.

//--- третий пример

double d2=(double)c1/2+0.3;

Print("(double)c1/2+0.3 = ",d2);

// Результат: (double)c1/2+0.3 = 1.80000000

Перед выполнением операции деления переменная c1 явно приводится к типу double. Теперь уже

целочисленная константа 2 приводится к значению 2.0 типа double, так как в результате

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

является одноместной операцией.

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

диапазона. В этом случае произойдет усечение. Например:

char c;

uchar u;

c=400;

u=400;

Print("c = ",c); // результат с=-112

Print("u = ",u); // результат u=144

Перед выполнением операций (кроме операций присваивания) происходит преобразование в тип,

имеющий наибольший приоритет, а перед операциями присваивания - в целевой тип.

Примеры:

int i=1/2; // приведения типов нет, результат: 0

Print("i = 1/2 ",i);

int k=1/2.0; // выражение приводится к типу double,

Print("k = 1/2 ",k); // затем приводится к целевому типу int, результат: 0

double d=1.0/2.0; // приведения типов нет, результат: 0.5

Print("d = 1/2.0; ",d);

double e=1/2.0; // выражение приводится к типу double,

Print("e = 1/2.0; ",e);// который совпадает с целевым типом, результат: 0.5

double x=1/2; // выражение типа int приводится к целевому типу double,

Print("x = 1/2; ",x); // результат: 0.0

Приведения для типа string

Тип string имеет самый высокий приоритет среди простых типов. Поэтому, если в операции один

из операндов имеет тип string, то другой операнд будет приведен к типу string автоматически.

Следует иметь ввиду, что для типа string допустима единственная двуместная операция

сложения. Допустимо явное приведение переменной типа string к любому числовому типу.

Примеры:

Основы языка

80

string s1=1.0/8; // выражение приводится к типу double,

Print("s1 = 1.0/8; ",s1); // затем к целевому типу string,

// результат:"0.12500000"(строка, содержащая 10 символов)

string s2=NULL; // деинициализация строки

Print("s2 = NULL; ",s2); // результат: пустая строка

string s3="Ticket N"+12345; // выражение приводится к типу string

Print("s = \"Ticket N\"+12345 ",s3);

string str1="true";

string str2="0,255,0";

string str3="2009.06.01";

string str4="1.2345e2";

Print(bool(str1));

Print(color(str2));

Print(datetime(str3));

Print(double(str4));

Приведение данных типа простых структур

Данные типа простыхструктур можно присваивать друг другу только в том случае, если все члены

обеих структур имеют числовые типы. При этом в операцииприсваивания оба операнда, и слева и

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

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

байт, соответствующее меньшему размеру. Таким образом компенсируется отсутствие

объединений (union) в языке MQL5.

Примеры:

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

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