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

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

Основы языка

121

Оператор уничтожения объекта delete

Оператор delete удаляет созданный оператором new объект, вызывает деструктор

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

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

delete описательобъекта становится недействительным.

Пример:

//--- удаляем уложенную фигуру

delete m_shape;

m_shape=NULL;

//--- создаём новую фигуру

NewShape();

Смотри также

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

уничтожение объектов

Основы языка

122

Функции

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

непосредственно представить в виде кода, либо разбить на еще более мелкие подзадачи. Данный

метод называется пошаговым уточнением. Функции служат для записи программного кода этих

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

определением функции:

заголовок_функции

{

инструкции

}

Все, что находится перед первой фигурной скобкой, составляет заголовок определения функции,

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

Заголовок функции включает в себя описание типа возвращаемого значения, имени (

идентификатора) и формальныхпараметров. Количество параметров, передаваемых в функцию,

ограничено и не может превышать 64.

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

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

функции.

Прототип функции – это объявление функции, но не ее определение. Благодаря явному

объявлению возвращаемого типа и списка типов аргументов, при обращении к функциям

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

функций используются в классах для улучшения читаемости кода.

Определение функции должно точно соответствовать ее объявлению. Каждая объявленная

функция должна быть определена.

Пример:

double // тип возвращаемого значения

linfunc (double a, double b) // имя функции и список параметров

{

// составной оператор

return (a + b); // возвращаемое значение

}

Оператор return может возвращать значение выражения, стоящего в этом операторе. Значение

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

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

Пример:

void errmesg(string s)

{

Print("error: "+s);

}

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

Основы языка

123

константами соответствующего типа.

Пример:

int somefunc(double a,

double d=0.0001,

int n=5,

bool b=true,

string s="passed string")

{

Print("Обязательный параметр a= ",a);

Print("Переданы следующие параметры: d = ",d," n = ",n," b = ",b," s = ",s);

return(0);

}

Если какому-либо параметру было назначено умолчательное значение, то все последующие

параметры также должны иметь умолчательное значение.

Пример неправильного объявления:

int somefunc(double a,

double d=0.0001, // объявлено значение по умолчанию 0.0001

int n, // значение по умолчанию не указано !

bool b, // значение по умолчанию не указано !

string s="passed string")

{

}

Смотри также

Перегрузка, Виртуальные функции, Полиморфизм

Основы языка

124

Вызов функции

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

левая круглая скобка, то оно по контексту считается именем некоторой функции.

имя_функции (x1, x2,..., xn)

Аргументы (формальныепараметры) передаются по значению, т. е. каждое выражение xl, . . . ,

xn вычисляется и значение передается функции. Порядок вычисления выражений и порядок

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

аргументов, переданных функции. Такой способ обращения к функции называется вызовом по

значению.

Вызов функции – это выражение, значением которого является значение, возвращаемое

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

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

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

Примеры:

int start()

{

double some_array[4]={0.3, 1.4, 2.5, 3.6};

double a=linfunc(some_array, 10.5, 8);

//...

}

double linfunc(double x[], double a, double b)

{

return (a*x[0] + b);

}

При вызове функции, имеющей умолчательные параметры, список передаваемых параметров

можно ограничить не ранее первого умолчательного параметра.

Примеры:

void somefunc(double init,

double sec=0.0001, //определены значения по умолчанию

int level=10);

//...

somefunc(); // неправильный вызов. первый обязательный параметр должен быть.

somefunc(3.14); // правильный вызов

somefunc(3.14,0.0002); // правильный вызов

somefunc(3.14,0.0002,10); // правильный вызов

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

somefunc(3.14, , 10); // неправильный вызов -> второй параметр пропущен.

Смотри также

Перегрузка, Виртуальные функции, Полиморфизм

Основы языка

125

Передача параметров

Существует два метода, с помощью которых машинный язык может передавать аргумент

подпрограмме (функции). Первый способ – передача параметра по значению. Этот метод копирует

значение аргумента в формальный параметр функции. Поэтому любые изменения этого

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

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

//| передача параметров по значению |

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

double FirstMethod(int i,int j)

{

double res;

//---

i*=2;

j/=2;

res=i+j;

//---

return(res);

}

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

//| Script program start function |

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

void OnStart()

{

//---

int a=14,b=8;

Print("a и b перед вызовом:",a," ",b);

double d=FirstMethod(a,b);

Print("a и b после вызова:",a," ",b);

}

//--- результат выполнения скрипта

// a и b перед вызовом: 14 8

// a и b после вызова: 14 8

Второй способ – передача аргумента по ссылке. В этом случае ссылка на параметр (а не его

значение) передается параметру функции. Внутри функции она используется для того, чтобы

обратиться к фактическому параметру, указанному в вызове. Это означает, что изменения

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

Основы языка

126

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

//| передача параметров по ссылке |

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

double SecondMethod(int &i,int &j)

{

double res;

//---

i*=2;

j/=2;

res=i+j;

//---

return(res);

}

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

//| Script program start function |

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

void OnStart()

{

//---

int a=14,b=8;

Print("a и b перед вызовом:",a," ",b);

double d=SecondMethod(a,b);

Print("a и b после вызова:",a," ",b);

}

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

//--- результат выполнения скрипта

// a и b перед вызовом: 14 8

// a и b после вызова: 28 4

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

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

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

использовать спецификатор доступа const. При попытке изменить содержимое переменной,

объявленной со спецификатором const, компилятор выдаст ошибку.

Примечание

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

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

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

Пример:

Основы языка

127

void OnStart()

{

//---

int a[]={0,1,2};

int i=0;

func(a[i],a[i++],"Первый вызов (i = "+string(i)+")");

func(a[i++],a[i],"Второй вызов (i = "+string(i)+")");

// Результат:

// Первый вызов(i=0) : par1 = 1 par2 = 0

// Второй вызов(i=1) : par1 = 1 par2 = 1

}

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

//| |

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

void func(int par1,int par2,string comment)

{

Print(comment,": par1 = ",par1," par2 = ",par2);

}

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

"Первый вызов (i = "+string(i)+")"

при этом ее значение не меняется. Затем переменная i участвует в вычислении элемента массива

a[i++], то есть после взятия i-го элемента массива переменная i инкрементируется. И только

после этого вычисляется первый параметр с измененным значением переменной i.

Во втором вызове при вычислении всех трех параметров используется одно и тоже значение i,

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

переменная i опять изменяется.

Смотри также

Область видимости и время жизни переменных, Перегрузка, Виртуальные функции,

Полиморфизм

Основы языка

128

Перегрузка функций

Обычно в названии функции стремятся отобразить ее основное назначение. Читабельные

программы, как правило, содержат разнообразные и грамотно подобранные идентификаторы.

Иногда различные функции используются для одних и тех же целей. Рассмотрим, например,

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

функцию, но оперирующую массивом целых чисел. И ту, и другую удобно назвать

AverageFromArray:

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

//| вычисление среднего для массива типа double |

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

double AverageFromArray(const double & array[],int size)

{

if(size<=0) return 0.0;

double sum=0.0;

double aver;

//---

for(int i=0;i<size;i++)

{

sum+=array[i]; // сложение для double

}

aver=sum/size; // просто делим сумму на количество

//---

Print("Вычисление среднего для массива типа double");

return aver;

}

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

//| вычисление среднего для массива типа int |

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

double AverageFromArray(const int & array[],int size)

{

if(size<=0) return 0.0;

double aver=0.0;

int sum=0;

//---

for(int i=0;i<size;i++)

{

sum+=array[i]; // сложение для double

}

aver=(double)sum/size;// приведем сумму к типу double и разделим

//---

Print("Вычисление среднего для массива типа int");

return aver;

}

Каждая функция содержит вывод сообщения посредством функции Print();

Print("Вычисление среднего для массива типа int");

Компилятор выбирает нужную функцию в соответствии с типами аргументов и их количеством.

Правило, по которому осуществляется этот выбор, называется алгоритмом соответствия

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

функции.

Пример:

Основы языка

129

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

//| Script program start function |

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

void OnStart()

{

//---

int a[5]={1,2,3,4,5};

double b[5]={1.1,2.2,3.3,4.4,5.5};

double int_aver=AverageFromArray(a,5);

double double_aver=AverageFromArray(b,5);

Print("int_aver = ",int_aver," double_aver = ",double_aver);

}

//--- Результат работы скрипта

// Вычисление среднего для массива типа int

// Вычисление среднего для массива типа double

// int_aver= 3.00000000 double_aver= 3.30000000

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

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

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

объявлении функции.

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

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

какого типа присутствуют. Наилучшее соответствие должно быть уникальным. Оно должно быть

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

всех других аргументов.

Ниже приведен алгоритм соответствия для каждого аргумента.

Алгоритм выбора перегруженной функции

1. Использовать строгое соответствие (если это возможно).

2. Попробовать стандартное повышение типа.

3. Попробовать стандартное преобразование типа.

Стандартное повышение типа лучше, чем остальные стандартные преобразования. Повышение -

это преобразование float в double, а также bool, char, short или enum в int. Кроме того, к

стандартным преобразованиям относятся преобразования массивов похожих целыхтипов.

Похожими типами являются: bool, char, uchar, так как все три типа являются однобайтовыми

целыми; двубайтовые целые short и ushort; 4-байтовые целые int, uint и color; long, ulong и

datetime.

Несомненно, строгое соответствие является наилучшим. Для достижения такого соответствия

могут использоваться приведения. Компилятор не справится с двусмысленной ситуацией. Поэтому

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

перегруженную функцию неясной.

Если Вы сомневаетесь, используйте явные преобразования для обеспечения строгого

соответствия.

Примеры перегруженных функций в MQL5 Вы можете увидеть на примере функций ArrayInitialize()

Основы языка

130

Правила перегрузки функций применимы к перегрузкеметодовклассов.

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

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

функцию fmax() 3-мя различными способами, но только два варианта будут корректными.

Пример:

// перегрузка допустима - отличается по количеству параметров

double fmax(double a,double b,double c);

// перегрузка с ошибкой

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

// это приводит к сокрытию системной функции при вызове, что недопустимо

double fmax(double a,double b,double c=DBL_MIN);

// нормальная перегрузка по типу параметра

int fmax(int a,int b);

Смотри также

Перегрузка, Виртуальные функции, Полиморфизм