Структуры, классы и интерфейсы
Структуры
Структура является набором элементов произвольного типа (кроме типа void). Таким образом, структура объединяет логически связанные данные разных типов.
Объявление структуры
Структурный тип данных определяется следующим описанием:
struct имя_структуры
{
описания_элементов
}; |
Имя структуры нельзя использовать в качестве идентификатора (имени переменной или функции). Следует иметь ввиду, что в MQL4 элементы структуры следуют непосредственно друг за другом без выравнивания. В языке C++ такое указание делается компилятору с помощью инструкции
Если требуется сделать иное выравнивание в структуре, необходимо использовать вспомогательные члены-"заполнители" нужных размеров.
Пример:
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 типа uchar. В этом случае внутреннее представление данных будет всегда одинаково независимо от значения, указанного в #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(const datetime t=0){m_call_time=t;};
//--- конструктор копирования
CFoo(const CFoo &foo){m_call_time=foo.m_call_time;};
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=D'2009.09.09'; // неявный вызов параметрического конструктора
CFoo foo40(foo1); // явный вызов конструктора копирования
CFoo foo41=foo1; // неявный вызов конструктора копирования
CFoo foo5; // явный вызов конструктора по умолчанию (если конструктор по умолчанию отсутствует,
// то вызывается параметрический конструктор с параметром по умолчанию)
//--- допустимые варианты получения указателей CFoo
CFoo *pfoo6=new CFoo(); // динамическое создание объекта и получение указателя на него
CFoo *pfoo7=new CFoo(TimeCurrent());// ещё один вариант динамического создания объекта
CFoo *pfoo8=GetPointer(foo1); // теперь pfoo8 указывает на объект foo1
CFoo *pfoo9=pfoo7; // pfoo9 и pfoo7 указывают на один и тот же объект
// CFoo foo_array[3]; // такой вариант использовать нельзя - конструктор по умолчанию не задан
//--- выведем значения m_call_time
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("pfoo6.m_call_time=",pfoo6.ToString());
Print("pfoo7.m_call_time=",pfoo7.ToString());
Print("pfoo8.m_call_time=",pfoo8.ToString());
Print("pfoo9.m_call_time=",pfoo9.ToString());
//--- удалим динамически созданные объекты
delete pfoo6;
delete pfoo7;
//delete pfoo8; // удалять pfoo8 явно не нужно, так как он указывает на автоматически созданный объект foo1
//delete pfoo9; // удалять pfoo9 явно не нужно, так как он указывает на тот же объект, что и pfoo7
} |
Если раскомментировать в этом примере строки
//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("Winnie","Pooh"); // Винни Пух
//--- выведем значения
Tom.PrintName();
Huck.PrintName();
Pooh.PrintName();
//--- удалим динамически созданный объект
delete Pooh;
} |
В данном случае класс CPerson имеет три конструктора:
- явный конструктор по умолчанию, который позволяет создавать массив объектов данного класса;
- конструктор с одним параметром, который принимает в качестве параметра полное имя и разделяет его на имя и фамилию по найденному пробелу;
- конструктор с двумя параметрами, который содержит список инициализации. Инициализаторы – m_second_name(surname) и m_first_name(name).
Обратите внимание, как инициализация с помощью списка заменила присваивание. Отдельные члены должны быть инициализированы как:
член_класса (список выражений) |
В списке инициализации члены могут идти в любом порядке, но при этом все члены класса будут инициализироваться согласно порядку их объявления. Это означает, что в третьем конструкторе сначала будет инициализирован член 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.
Деструктор - это специальная функция, которая вызывается автоматически при уничтожении объекта класса. Имя деструктора записывается как имя класса с тильдой (~). Строки, динамические массивы и объекты, требующие деинициализации, в любом случае будут деинициализированы независимо от наличия деструктора. При наличии деструктора, эти действия будут произведены после вызова деструктора.
Деструкторы всегда являются виртуальными, независимо от того, объявлены они с ключевым слово 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[]) только объявлены внутри класса, но пока не определены. Определения этих функций должны следовать далее по коду. Для того чтобы определить метод вне класса используется операция разрешения контекста, в качестве контекста используется имя класса.
Пример:
//+------------------------------------------------------------------+
//| Конструктор базового класса |
//+------------------------------------------------------------------+
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:
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: (и до следующего спецификатора доступа), доступны только функциям-членам этого класса. Спецификаторы доступа к элементам всегда заканчиваются двоеточием (:) и могут появляться в определении класса много раз.
Доступ к членам базового класса может переопределяться при наследовании в производных классах.
Модификатор final
Наличие модификатора final при объявлении класса запрещает дальнейшее наследование от него. Если интерфейс класса таков, что нет необходимости вносить в него дальнейшие изменения, или изменения не допустимы по соображениям безопасности, объявите класс с модификатором final. При этом все методы класса будут также неявно считаться final.
class CFoo final
{
//--- тело класса
};
class CBar : public CFoo
{
//--- тело класса
}; |
При попытке наследования от класса с модификатором final, как показано в примере выше, компилятор выдаст ошибку:
cannot inherit from 'CFoo' as it has been declared as 'final'
see declaration of 'CFoo' |
Объединение (union)
Объединение – это особый тип данных, который состоит из нескольких переменных, разделяющих одну и ту же область памяти. Следовательно, объединение обеспечивает возможность интерпретации одной и той же последовательности битов двумя (или более) различными способами. Объявление объединения подобно объявлению структуры и начинается с ключевого слова union.
union LongDouble
{
long long_value;
double double_value;
}; |
Но в отличие от структуры, разные члены объединения относятся к одному и тому же участку памяти. В данном примере объявлено объединение LongDouble, в котором значение типа long и значение типа double разделяют одну и ту же область памяти. Важно понимать - невозможно сделать так, чтобы это объединение хранило одновременно целочисленное значение long и вещественное double (как это было бы в структуре), поскольку переменные long_value и double_value накладываются (в памяти) друг на друга. Но зато MQL5-программа в любой момент может обрабатывать информацию, содержащуюся в этом объединении, как целочисленное значение (long) или как вещественное (double). Следовательно, объединение позволяет получить два (или больше) варианта представления одной и той же последовательности данных.
При объявлении объединения компилятор автоматически выделяет область памяти, достаточную для хранения в объединении переменных самого большого по объему типа. Для доступа к элементу объединения используется тот же синтаксис, как и для структур – оператор "точка".
union LongDouble
{
long long_value;
double double_value;
};
//+------------------------------------------------------------------+
//| Script program start function |
//+------------------------------------------------------------------+
void OnStart()
{
//---
LongDouble lb;
//--- получим недействительное число -nan(ind) и выведем его
lb.double_value=MathArcsin(2.0);
printf("1. double=%f integer=%I64X",lb.double_value,lb.long_value);
//--- наибольшее нормализованное число (DBL_MAX)
lb.long_value=0x7FEFFFFFFFFFFFFF;
printf("2. double=%.16e integer=%I64X",lb.double_value,lb.long_value);
//--- наименьшее положительное нормализованное (DBL_MIN)
lb.long_value=0x0010000000000000;
printf("3. double=%.16e integer=%.16I64X",lb.double_value,lb.long_value);
}
/* Результат выполнения
1. double=-nan(ind) integer=FFF8000000000000
2. double=1.7976931348623157e+308 integer=7FEFFFFFFFFFFFFF
3. double=2.2250738585072014e-308 integer=0010000000000000
*/ |
Поскольку объединения позволяют программе интерпретировать одни и те же данные в памяти по-разному, они часто используются в случаях, когда требуется необычное преобразование типов.
Объединения не могут участвовать в наследовании, а также они не могут иметь статических членов по определению. В остальном union ведёт себя как структура, у которой все члены имеют нулевое смещение. При этом членами объединения не могут быть следующие типы:
Также как и классы, объединение может иметь конструкторы и деструкторы, а также и методы. По умолчанию члены объединения имеют тип доступа public, для создания закрытых элементов необходимо использовать ключевое слово private. Все эти возможности представлены в примере, который показывает как преобразовать цвет, имеющий тип color, в представление ARGB, как это делает функция ColorToARGB().
//+------------------------------------------------------------------+
//| Объединение для конвертации color(BGR) в представление ARGB |
//+------------------------------------------------------------------+
union ARGB
{
uchar argb[4];
color clr;
//--- конструкторы
ARGB(color col,uchar a=0){Color(col,a);};
~ARGB(){};
//--- публичные методы
public:
uchar Alpha(){return(argb[3]);};
void Alpha(const uchar alpha){argb[3]=alpha;};
color Color(){ return(color(clr));};
//--- закрытые методы
private:
//+------------------------------------------------------------------+
//| установка цвета и значения альфа-канала |
//+------------------------------------------------------------------+
void Color(color col,uchar alpha)
{
//--- установим цвет в член clr
clr=col;
//--- установим значение компонента Alpha - уровня непрозрачности
argb[3]=alpha;
//--- переставим местами байты компонент R и B (Red и Blue)
uchar t=argb[0];argb[0]=argb[2];argb[2]=t;
};
};
//+------------------------------------------------------------------+
//| Script program start function |
//+------------------------------------------------------------------+
void OnStart()
{
//--- значение 0x55 означает 55/255=21.6 % (0% - полностью прозрачный)
uchar alpha=0x55;
//--- тип color имеет представление 0x00BBGGRR
color test_color=clrDarkOrange;
//--- сюда будем принимать значения байтов из объединения ARGB
uchar argb[];
PrintFormat("0x%.8X - так выглядит тип color для %s, BGR=(%s)",
test_color,ColorToString(test_color,true),ColorToString(test_color));
//--- тип ARGB представлен как 0x00RRGGBB, переставлены местами RR и BB компоненты
ARGB argb_color(test_color);
//--- скопируем массив байтов
ArrayCopy(argb,argb_color.argb);
//--- посмотрим как выглядит в представлении ARGB
PrintFormat("0x%.8X - представление ARGB c альфа-каналом=0x%.2x, ARGB=(%d,%d,%d,%d)",
argb_color.clr,argb_color.Alpha(),argb[3],argb[2],argb[1],argb[0]);
//--- добавим значение непрозрачности
argb_color.Alpha(alpha);
//--- попробуем вывести ARGB как тип color
Print("ARGB как color=(",argb_color.clr,") альфа-канал=",argb_color.Alpha());
//--- скопируем массив байтов
ArrayCopy(argb,argb_color.argb);
//--- а вот как выглядит в представлении ARGB
PrintFormat("0x%.8X - представление ARGB c альфа-каналом=0x%.2x, ARGB=(%d,%d,%d,%d)",
argb_color.clr,argb_color.Alpha(),argb[3],argb[2],argb[1],argb[0]);
//--- сверим с тем, что выдает функция ColorToARGB()
PrintFormat("0x%.8X - результат ColorToARGB(%s,0x%.2x)",ColorToARGB(test_color,alpha),
ColorToString(test_color,true),alpha);
}
/* Результат выполнения
0x00008CFF - так выглядит тип color для clrDarkOrange, BGR=(255,140,0)
0x00FF8C00 - представление ARGB c альфа-каналом=0x00, ARGB=(0,255,140,0)
ARGB как color=(0,140,255) альфа-канал=85
0x55FF8C00 - представление ARGB c альфа-каналом=0x55, ARGB=(85,255,140,0)
0x55FF8C00 - результат ColorToARGB(clrDarkOrange,0x55)
*/ |
Интерфейсы
Интерфейс предназначен для определения определённого функционала, который класс впоследствии может реализовывать. Фактически, это класс, который не может содержать члены и не может иметь конструктор и/или деструктор. Все объявленные в интерфейсе методы являются чисто виртуальными, даже без явного определения.
Определяется интерфейс с помощью ключевого слова interface, как показано в примере:
//--- базовый интерфейс для описания животных
interface IAnimal
{
//--- методы интерфейса по умолчанию имеют public-доступ
void Sound(); // звук, который издает животное
};
//+------------------------------------------------------------------+
//| класс CCat наследуется от интерфейса IAnimal |
//+------------------------------------------------------------------+
class CCat : public IAnimal
{
public:
CCat() { Print("Cat was born"); }
~CCat() { Print("Cat is dead"); }
//--- реализуем метод Sound интерфейса IAnimal
void Sound(){ Print("meou"); }
};
//+------------------------------------------------------------------+
//| класс CDog наследуется от интерфейса IAnimal |
//+------------------------------------------------------------------+
class CDog : public IAnimal
{
public:
CDog() { Print("Dog was born"); }
~CDog() { Print("Dog is dead"); }
//--- реализуем метод Sound интерфейса IAnimal
void Sound(){ Print("guaf"); }
};
//+------------------------------------------------------------------+
//| Script program start function |
//+------------------------------------------------------------------+
void OnStart()
{
//--- массив указателей на объекты типа IAnimal
IAnimal *animals[2];
//--- породим потомков IAnimal и сохраним указатели на них в массив
animals[0]=new CCat;
animals[1]=new CDog;
//--- вызовем метод Sound() базового интерфейса IAnimal для каждого потомка
for(int i=0;i<ArraySize(animals);++i)
animals[i].Sound();
//--- удалим объекты
for(int i=0;i<ArraySize(animals);++i)
delete animals[i];
//--- результат выполнения
/*
Cat was born
Dog was born
meou
guaf
Cat is dead
Dog is dead
*/
} |
Как и в случае абстрактных классов, нельзя создавать объект интерфейса без наследования. Интерфейс может наследоваться только от других интерфейсов и может выступать предком для класса. При этом интерфейс всегда имеет публичную видимость.
Интерфейс нельзя объявить внутри объявления класса или структуры, но при этом указатель на интерфейс можно сохранить в переменную типа void *. Вообще говоря, в переменную типа void * можно сохранить указатель на объект любого класса. Для того чтобы преобразовать указатель void * в указатель на объект конкретного класса, необходимо использовать оператор dynamic_cast. В случае, когда преобразование невозможно, результатом операции dynamic_cast будет NULL.
Смотри также
Объектно-ориентированное программирование
Основы языка 
