MQL5-架构和类以及界面_mql5 struct

MQL5-架构和类以及界面

架构

架构是设定任何类型的元素（除了空型），因此，架构要组合不同类型的逻辑相关资料。

架构说明

以下描述定义结构类型数据：

struct structure_name  
{   
elements_description  
}; 
1
2
3
4

架构名称不能用作标识符（变量或功能的名称），应该直接记录在MQL5架构元素中，没有定位， 在C++中需要遵循以下指令来定义这些命令：

#pragma pack(1) 
1

如果想在架构中执行另一定位，运用辅助程序，“ fillers” 填充正确大小。

示例：

struct trade_settings  
{   
uchar  slippage;     // 许可的下降值1字节大小    
char   reserved1;    // 跳过 1 字节    
short  reserved2;    // 跳过 2 字节    
int    reserved4;    // 跳过另4个字节。确保定位8字节界限    
double take;         // 固定利润价格值    
double stop;         // 受保护的止损价格值   
}; 
1
2
3
4
5
6
7
8
9

线性构造的描述只对动态传输功能入口有效。

注意：该例子列举的是错误的设计数据，在双精度型数据中，首先声明take和stop的数据大小比较好，然后是slippage，在此情况下，数据的内部表达式与 #pragma pack ()无关，都是一样的。

如果该构造包含字符串型数据变量，和/ 或目标动态数组，编译器给架构分派隐含的构造函数。 构造函数设置所有字符串型和初始化目标动态数组的所有结构。

简单构造

没有包含字符串，类对象，指针和动态数组对象的构造被称为简单构造。简单构造的变量及其数组可以作为参数从DLL被传递到imported函数。

仅允许在下面两种情况下复制简单构造：

• 如果对象属于相同的构造类型

• 如果对象通过血统连接，这意味着一个构造是另一个构造的后代

  若要提供示例，让我们来开发一个CustomMqlTick自定义构造，其内容与内置的MqlTick内容是一 致的。编译器不允许复制MqlTick对象值到CustomMqlTick类型对象。直接类型转换到所需类型也会引起编译错误：

 //--- 禁止复制不同类型的简单构造       
 my_tick1=last_tick;               // 这里编译器返回错误

 //--- 同时也禁止不同类型构造彼此的类型转换       
my_tick1=(CustomMqlTick)last_tick;// 这里编译器返回错误 
1
2
3
4
5

因此，只留有一个选项 – 依次复制构造元素的值。仍然允许复制CustomMqlTick相同类型的值。

 CustomMqlTick my_tick1,my_tick2;       
 //--- 允许复制CustomMqlTick以下相同类型的对象       
 my_tick2=my_tick1;           

 //--- 从CustomMqlTick简单构造对象创建一个数组并为其写值       
 CustomMqlTick arr[2];       
 arr[0]=my_tick1;      
 arr[1]=my_tick2;   
1
2
3
4
5
6
7
8

调用ArrayPrint()函数进行检查以在日志中显示arr[] 数组值 。

//+------------------------------------------------------------------+  
//| 脚本程序起始函数                                                   |  
//+------------------------------------------------------------------+  
void OnStart()   
   {  
//--- 开发类似于内置MqlTick的构造    
struct CustomMqlTick      
     {      
       datetime          time;          // 最后价格更新时间       
       double            bid;           // 当前卖价       
       double            ask;           // 当前买价       
       double            last;          // 最后一笔交易的当前价格(Last)       
       ulong             volume;        // 当前最后价格的交易量      
        long              time_msc;      // 以毫秒计算的最后价格更新时间       
        uint              flags;         // 报价标识           
        };    
        //--- 获得最后报价值    
        MqlTick last_tick;    
        CustomMqlTick my_tick1,my_tick2;  
  //--- 尝试从MqlTick复制数据到CustomMqlTick   
     if(SymbolInfoTick(Symbol(),last_tick))      
     {       
     //--- 禁止复制不相关的简单构造       
     //1. my_tick1=last_tick;               // 这里编译器返回错误          

     //--- 同时也禁止不相关构造彼此的类型转换      
     //2. my_tick1=(CustomMqlTick)last_tick;// 这里编译器返回错误    
//--- 因此，依次复制构造成员            
 my_tick1.time=last_tick.time;       
 my_tick1.bid=last_tick.bid;      
 my_tick1.ask=last_tick.ask;      
 my_tick1.volume=last_tick.volume;       
 my_tick1.time_msc=last_tick.time_msc;      
 my_tick1.flags=last_tick.flags;           

 //--- 允许复制CustomMqlTick以下相同类型的对象       
 my_tick2=my_tick1;            
 //--- 从CustomMqlTick简单构造对象创建一个数组并为其写值       
 CustomMqlTick arr[2];       
 arr[0]=my_tick1;       
 arr[1]=my_tick2;       
 ArrayPrint(arr);  
 //--- 显示包含CustomMqlTick类型对象的数组值的示例       
 /*                        
 [time]   [bid]   [ask]   [last] [volume]    [time_msc] [flags]       
 [0] 2017.05.29 15:04:37 1.11854 1.11863 +0.00000  1450000 1496070277157       2       
 [1] 2017.05.29 15:04:37 1.11854 1.11863 +0.00000  1450000 1496070277157       2                 
  */     
   }    
   else      
    Print("SymbolInfoTick() failed, error = ",GetLastError());   
    } 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

第二个示例显示通过血统复制简单构造的特性。假设我们有Animal基本构造，从此得到了Cat和 Dog的构造。我们可以彼此复制Animal和Cat对象，以及Animal和Dog对象，但我们不能彼此复制 Cat 和Dog，虽然这两种都是衍生自Animal构造。

//--- 描述狗的构造  
struct Dog: Animal   
{    
bool              hunting;       // 狩猎犬   
};  
//--- 描述猫的构造  
struct Cat: Animal   
{    
bool              home;          // 家猫   
};  
//--- 创建子构造对象   
 Dog dog;    
 Cat cat;  
 //--- 可以从母系复制到后代 (Animal ==> Dog)    
 dog=some_animal;   dog.swim=true;    // 狗可以游泳  
 //--- 您不能复制子构造的对象 (Dog != Cat)    
 cat=dog;        // 编译器返回错误
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

完整的示例代码：

//--- 描述动物的基本构造  
struct Animal   
{    
int               head;          // 头部数量    
int               legs;          // 腿的数量    
int               wings;         // 翅膀数量    
bool              tail;          // 尾巴    
bool              fly;           // 飞行   
bool              swim;          // 游泳      
bool              run;           // 跑步   
};  
//--- 描述狗的构造  
struct Dog: Animal   
{    
bool              hunting;       // 狩猎犬   
};  
//--- 描述猫的构造  
struct Cat: Animal   
{    
bool              home;          // 家猫   
};  
//+------------------------------------------------------------------+  
//| 脚本程序起始函数                                                   |  
//+------------------------------------------------------------------+  
void OnStart()   
{  
//--- 创建和描述基本Animal类型的对象    
Animal some_animal;    
some_animal.head=1;    
some_animal.legs=4;    
some_animal.wings=0;    
some_animal.tail=true;    
some_animal.fly=false;    
some_animal.swim=false;    
some_animal.run=true;  
//--- 创建子类型对象    
Dog dog;    
Cat cat;  
//--- 可以从母系复制到后代 (Animal ==> Dog)    
dog=some_animal;    
dog.swim=true;     // 狗可以游泳  
//--- 您不能复制子构造的对象 (Dog != Cat)    
//cat=dog;        // 这里编译器返回错误  
//--- 因此，只可以依次复制元素    
cat.head=dog.head;    
cat.legs=dog.legs;    
cat.wings=dog.wings;
cat.tail=dog.tail;    
cat.fly=dog.fly;    
cat.swim=false;   // 猫不可以游泳  
//--- 可以从后代复制值到祖先    
Animal elephant;    
elephant=cat;    
elephant.run=false;// 大象不可以跑步    
elephant.swim=true;// 大象可以游泳  
//--- 创建数组    
Animal animals[4];    
animals[0]=some_animal;    
animals[1]=dog;      
animals[2]=cat;    
animals[3]=elephant;  
//--- 打印出    
ArrayPrint(animals);  
//--- 执行结果  
/*        
[head] [legs] [wings] [tail] [fly] [swim] [run]    
[0]      1      4       0   true false  false  true    
[1]      1      4       0   true false   true  true    
[2]      1      4       0   true false  false false    
[3]      1      4       0   true false   true false  
*/     
} 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

复制简单类型的另一种方式是使用一个联合。构造对象应该是相同联合的成员 。

接入架构会员入口

架构是一种新的数据型用来声明这种类型变量的，只有在一个项目开始是架构可以运行，架构会员可以通过
操作点 (.)进入接口。

示例

struct trade_settings   
{    
double take;         // 利润固定价格值    
double stop;         // 受保护的止损价格值    
uchar  slippage;     // 可接受的下降值   
};  
//--- 创建和初始化交易设置类型的变量  
trade_settings my_set={0.0,0.0,5};   
if (input_TP>0) my_set.take=input_TP; 
1
2
3
4
5
6
7
8
9

修饰符“final”

架构声明过程中使用’ final’ 修饰符禁止从该架构进一步继承。如果架构无需进一步修改，或出于安全原因不允许修改，则以’ final’修饰符声明该架构。此外，该架构的所有成员也将默认为不可更改。

struct settings final   
{   
//--- 构造主体   
};
 struct trade_settings : public settings   
 {   
 //--- 构造主体   
 }; 
1
2
3
4
5
6
7
8

如果您像上面示例一样试图以 ’ final’ 修饰符继承形成一个架构，编译器将返回一个错误：