mql5项目

admin

原代码

1. #property copyright "QQ:2913811"
   
2. #property link      "gzpu.com"
   
3. 
   
4. extern int BuyOrSell = 0;//0=多 1=空 第一单多空
   
5. extern int MaxTrades = 7;//单向最大持仓单数
   
6. extern int sliptime = 30;//等待时间秒
   
7. extern int slippage = 3;//滑点
   
8. extern int MagicN = 10533;//定单识别码
   
9. extern string Commentt = "QQ:2913811";//定单注释
   
10. extern string Temp0 = "======每单下单量======";
    
11. extern double Lots1 = 0.01;
    
12. extern double Lots2 = 0.02;
    
13. extern double Lots3 = 0.04;
    
14. extern double Lots4 = 0.07;
    
15. extern double Lots5 = 0.09;
    
16. extern double Lots6 = 0.12;
    
17. extern double Lots7 = 0.15;
    
18. extern string Temp1 = "======每单间隔======";
    
19. extern double Pips1 = 15;
    
20. extern double Pips2 = 15;
    
21. extern double Pips3 = 15;
    
22. extern double Pips4 = 15;
    
23. extern double Pips5 = 15;
    
24. extern double Pips6 = 15;
    
25. extern double Pips7 = 15;
    
26. extern string Temp2 = "======每单止盈======";
    
27. extern double TP1 = 15;
    
28. extern double TP2 = 15;
    
29. extern double TP3 = 15;
    
30. extern double TP4 = 15;
    
31. extern double TP5 = 15;
    
32. extern double TP6 = 15;
    
33. extern double TP7 = 15;
    
34. 
    
35. double Gda_292[7];
    
36. double Gda_296[7];
    
37. double Gda_300[7];
    
38. double Gd_304;
    
39. double Gd_312;
    
40. double Gd_320;
    
41. double Gd_328;
    
42. double Gd_336;
    
43. double Gd_344;
    
44. double G_order_open_price_352;
    
45. double G_order_open_price_360;
    
46. double Gd_368;
    
47. double Gd_376;
    
48. bool G_bool_384;
    
49. int G_pos_388;
    
50. int G_index_392;
    
51. int G_index_396;
    
52. int G_ticket_400;
    
53. int Gi_404 = 1;
    
54. double G_price_408;
    
55. bool TarckInt0;
    
56. bool TarckInt1;
    
57. bool Open0 = false;
    
58. bool Open1 = false;
    
59. bool TarckKaiGuan0 = false;
    
60. bool TarckKaiGuan1 = false;
    
61. int Time0 = 0;
    
62. int Time1 = 0;
    
63. 
    
64. int init() {
    
65.    Gda_292[0] = Lots1;
    
66.    Gda_292[1] = Lots2;
    
67.    Gda_292[2] = Lots3;
    
68.    Gda_292[3] = Lots4;
    
69.    Gda_292[4] = Lots5;
    
70.    Gda_292[5] = Lots6;
    
71.    Gda_292[6] = Lots7;
    
72.    Gda_296[0] = Pips1;
    
73.    Gda_296[1] = Pips2;
    
74.    Gda_296[2] = Pips3;
    
75.    Gda_296[3] = Pips4;
    
76.    Gda_296[4] = Pips5;
    
77.    Gda_296[5] = Pips6;
    
78.    Gda_296[6] = Pips7;
    
79.    Gda_300[0] = TP1;
    
80.    Gda_300[1] = TP2;
    
81.    Gda_300[2] = TP3;
    
82.    Gda_300[3] = TP4;
    
83.    Gda_300[4] = TP5;
    
84.    Gda_300[5] = TP6;
    
85.    Gda_300[6] = TP7;
    
86.    if (Digits == 5 || Digits == 3) Gi_404 = 10;
    
87.    if (StringFind(Symbol(), "XAU", 0) >= 0 || StringFind(Symbol(), "GOLD", 0) >= 0) {
    
88.       if (Digits == 2) Gi_404 = 10;
    
89.       if (Digits == 3) Gi_404 = 100;
    
90.    }
    
91.    return (0);
    
92. }
    
93. 
    
94. int start() {
    
95.    CountOrders();
    
96.    TarckInt0 = false;
    
97.    TarckInt1 = false;
    
98.    if ((G_index_392 + G_index_396 == 0 && BuyOrSell == 0) || (G_index_392 > 0 && G_index_392 < MaxTrades && G_order_open_price_352 - Ask >= (Gda_296[G_index_392 - 1]) * Gi_404 * Point)) {
    
99.       TarckInt0 = true;
    
100.       if (G_index_392 == 0) Open0 = true;
     
101.       if (TarckKaiGuan0 && TimeCurrent() - Time0 >= sliptime) Open0 = true;
     
102.       if (G_index_392 > 0 && !TarckKaiGuan0) {
     
103.          Open0 = false;
     
104.          TarckKaiGuan0 = true;
     
105.          Time0 = TimeCurrent();
     
106.          }
     
107.       if(Open0) {
     
108.          G_ticket_400 = OrderSend(Symbol(), OP_BUY, Gda_292[G_index_392], Ask, slippage * Gi_404, 0, 0, Commentt, MagicN, 0, Blue);
     
109.          if (G_ticket_400 > 0) {
     
110.             Open0 = false;
     
111.             BuyOrSell = TRUE;
     
112.             O_Modify(OP_BUY);
     
113.           }
     
114.       }
     
115.    }
     
116.    if ((G_index_392 + G_index_396 == 0 && BuyOrSell == 1) || (G_index_396 > 0 && G_index_396 < MaxTrades && Bid - G_order_open_price_360 >= (Gda_296[G_index_396 - 1]) * Gi_404 * Point)) {
     
117.       TarckInt1 = true;
     
118.       if (G_index_396 == 0) Open1 = true;
     
119.       if (TarckKaiGuan1 && TimeCurrent() - Time1 >= sliptime) Open1 = true;
     
120.       if (G_index_396 > 0 && !TarckKaiGuan1) {
     
121.          Open1 = false;
     
122.          TarckKaiGuan1 = true;
     
123.          Time1 = TimeCurrent();
     
124.          }
     
125.       if(Open1) {
     
126.       G_ticket_400 = OrderSend(Symbol(), OP_SELL, Gda_292[G_index_396], Bid, slippage * Gi_404, 0, 0, Commentt, MagicN, 0, Red);
     
127.       if (G_ticket_400 > 0) {
     
128.          BuyOrSell = FALSE;
     
129.          O_Modify(OP_SELL);
     
130.          }
     
131.       }
     
132.    }
     
133.    if(!TarckInt0) TarckKaiGuan0 = false;
     
134.    if(!TarckInt1) TarckKaiGuan1 = false;
     
135.    return (0);
     
136. }
     
137. 
     
138. void O_Modify(int A_cmd_0) {
     
139.    CountOrders();
     
140.    if (A_cmd_0 == OP_BUY) G_price_408 = G_order_open_price_352 + (Gda_300[G_index_392 - 1]) * Gi_404 * Point;
     
141.    if (A_cmd_0 == OP_SELL) G_price_408 = G_order_open_price_360 - (Gda_300[G_index_396 - 1]) * Gi_404 * Point;
     
142.    for (int pos_4 = OrdersTotal() - 1; pos_4 >= 0; pos_4--) {
     
143.       if (OrderSelect(pos_4, SELECT_BY_POS, MODE_TRADES)) {
     
144.          if (OrderSymbol() == Symbol() && OrderType() == A_cmd_0)
     
145.             if (OrderTakeProfit() != G_price_408) G_bool_384 = OrderModify(OrderTicket(), OrderOpenPrice(), OrderStopLoss(), G_price_408, 0, Yellow);
     
146.       }
     
147.    }
     
148. }
     
149. 
     
150. void CountOrders() {
     
151.    G_index_392 = 0;
     
152.    G_index_396 = 0;
     
153.    Gd_320 = 0;
     
154.    Gd_328 = 0;
     
155.    Gd_304 = 0;
     
156.    Gd_312 = 0;
     
157.    Gd_336 = 0;
     
158.    Gd_344 = 0;
     
159.    G_order_open_price_352 = 0;
     
160.    G_order_open_price_360 = 0;
     
161.    Gd_368 = 0;
     
162.    Gd_376 = 0;
     
163.    for (G_pos_388 = 0; G_pos_388 < OrdersTotal(); G_pos_388++) {
     
164.       if (OrderSelect(G_pos_388, SELECT_BY_POS, MODE_TRADES)) {
     
165.          if (OrderSymbol() == Symbol() && OrderMagicNumber() == MagicN) {
     
166.             if (OrderType() == OP_BUY) {
     
167.                G_index_392++;
     
168.                Gd_304 += OrderLots();
     
169.                Gd_320 += OrderProfit();
     
170.                Gd_336 += OrderLots() * OrderOpenPrice();
     
171.                G_order_open_price_352 = OrderOpenPrice();
     
172.             }
     
173.             if (OrderType() == OP_SELL) {
     
174.                G_index_396++;
     
175.                Gd_312 += OrderLots();
     
176.                Gd_328 += OrderProfit();
     
177.                Gd_344 += OrderLots() * OrderOpenPrice();
     
178.                G_order_open_price_360 = OrderOpenPrice();
     
179.             }
     
180.          }
     
181.       }
     
182.    }
     
183.    if (Gd_304 != 0.0) Gd_368 = NormalizeDouble(Gd_336 / Gd_304, Digits);
     
184.    if (Gd_312 != 0.0) Gd_376 = NormalizeDouble(Gd_344 / Gd_312, Digits);
     
185. }
     

复制代码

admin

这段 MQL5 代码是一个基于 MetaTrader 5 (MT5) 的 EA（智能交易系统）脚本，主要功能如下：

参数设置：

定义了多个外部变量用于控制交易方向（BuyOrSell）、最大持仓单数（MaxTrades）、等待时间（sliptime）、滑点（slippage）、订单识别码（MagicN）以及与每笔交易相关的下单量（Lots1-Lots7）、间隔（Pips1-Pips7）和止盈目标（TP1-TP7）。
全局变量：

定义了一系列的数组和双精度浮点数变量，用于存储每笔交易的相关数据，如下单量、价格间隔和止盈值等。
还定义了一些布尔型变量和整型变量，用于跟踪订单状态、开平仓标志、时间和订单索引等信息。
初始化函数init()：

初始化了各个交易单位的数量、价格间隔和止盈目标，并根据交易品种的报价小数位数调整了一些计算参数。
启动函数start()：

主要处理下单逻辑，当满足一定的条件时（如当前无持仓或某个方向上还有剩余交易次数且满足价格条件），尝试进行买卖操作。
使用 OrderSend 函数发送订单，并在成功下单后调用 O_Modify 函数来修改订单的止损和止盈。
O_Modify 函数：

根据交易方向计算并设定相应的止盈价格，然后遍历所有交易订单，对符合条件的订单执行 OrderModify 操作以更新其止损和止盈。
CountOrders 函数：

计算当前交易品种下，EA 所管理的所有订单的统计信息，包括多空持仓数量、总盈利、平均入场价格等。
整体来看，这个 EA 脚本采用的是分批加仓的方式进行交易，每次加仓的数量和间隔是预先设置好的，并根据市场行情动态地开启新的加仓批次。同时，它还具有实时监控订单并调整止损和止盈的能力。

admin

优化建议：
虽然这段代码实现了基本的批量加仓交易策略，但为了提升代码可读性和维护性，以及潜在的性能优化，以下是一些建议：

变量命名规范：

变量名应当清晰明了，反映其用途，例如G_order_open_price_352这样的变量名不易理解，可以改为last_buy_order_open_price或类似更具描述性的名称。
结构化数据：

可以考虑使用结构体或类来封装一组相关联的数据（如下单量、价格间隔、止盈距离），避免使用多个数组分别存储这些属性。
减少重复代码：

开仓逻辑分为两个几乎完全相同的分支（买和卖），可以通过抽象出一个通用函数来处理这两种情况，减少重复代码。
代码组织：

将一些逻辑独立为单独的函数，如“判断是否满足开仓条件”、“更新订单统计信息”等，提高代码的模块化程度。
错误处理：

在OrderSend和OrderModify调用之后，应检查返回值并处理可能出现的错误，如网络连接失败、超出账户风险限制等情况。
注释和文档：

增加必要的注释，解释关键算法思路、重要变量的作用以及函数的主要功能，以便于其他开发者理解和维护代码。
条件判断优化：

对于复杂嵌套的条件判断，可以尝试简化或重构，使得代码更简洁高效。

admin

完整优化后的代码

1. #include <stdio.h>
   
2. #include <MetaTrader5/MetaTrader5.h>
   
3. 
   
4. // 定义交易批次结构体
   
5. struct TradeBatch {
   
6.     double lot_size;
   
7.     double price_interval;
   
8.     double take_profit;
   
9. };
   
10. 
    
11. extern int BuyOrSell = 0; // 0=多, 1=空
    
12. extern int MaxTrades = 7;
    
13. extern int sliptime = 30;
    
14. extern int slippage = 3;
    
15. extern int MagicN = 10533;
    
16. extern string Commentt = "QQ:2913811";
    
17. 
    
18. // 交易批次列表
    
19. TradeBatch trade_batches[7];
    
20. 
    
21. double current_bid_price;
    
22. double current_ask_price;
    
23. int long_index = 0;
    
24. int short_index = 0;
    
25. 
    
26. bool OpenLong = false;
    
27. bool OpenShort = false;
    
28. bool TrackOpenLong = false;
    
29. bool TrackOpenShort = false;
    
30. datetime TimeLong = 0;
    
31. datetime TimeShort = 0;
    
32. 
    
33. void OnInit() {
    
34.     SetIndexStyle(0, DRAW_LINE, EMPTY);
    
35.     SetIndexBuffer(0, Gda_296);
    
36.    
    
37.     trade_batches[0] = {0.01, 15, 15};
    
38.     trade_batches[1] = {0.02, 15, 15};
    
39.     trade_batches[2] = {0.04, 15, 15};
    
40.     trade_batches[3] = {0.07, 15, 15};
    
41.     trade_batches[4] = {0.09, 15, 15};
    
42.     trade_batches[5] = {0.12, 15, 15};
    
43.     trade_batches[6] = {0.15, 15, 15};
    
44. 
    
45.     for (int i = 0; i < 7; ++i) {
    
46.         if (Digits == 5 || Digits == 3) {
    
47.             trade_batches[i].price_interval *= 10;
    
48.             trade_batches[i].take_profit *= 10;
    
49.         }
    
50.         else if (StringFind(Symbol(), "XAU", 0) >= 0 || StringFind(Symbol(), "GOLD", 0) >= 0 && (Digits == 2 || Digits == 3)) {
    
51.             trade_batches[i].price_interval *= (Digits == 2 ? 10 : 100);
    
52.             trade_batches[i].take_profit *= (Digits == 2 ? 10 : 100);
    
53.         }
    
54.     }
    
55. }
    
56. 
    
57. void OnTick() {
    
58.     CountOrders();
    
59.     TrackOpenLong = false;
    
60.     TrackOpenShort = false;
    
61.     current_bid_price = Bid;
    
62.     current_ask_price = Ask;
    
63. 
    
64.     if ((long_index + short_index == 0 && BuyOrSell == 0) || (long_index > 0 && long_index < MaxTrades && CheckOpenPosition(OP_BUY))) {
    
65.         TrackOpenLong = true;
    
66.         TryOpenPosition(OP_BUY, long_index, OpenLong, TimeLong);
    
67.     }
    
68. 
    
69.     if ((long_index + short_index == 0 && BuyOrSell == 1) || (short_index > 0 && short_index < MaxTrades && CheckOpenPosition(OP_SELL))) {
    
70.         TrackOpenShort = true;
    
71.         TryOpenPosition(OP_SELL, short_index, OpenShort, TimeShort);
    
72.     }
    
73. 
    
74.     if (!TrackOpenLong) ResetTrack(OpenLong, TimeLong);
    
75.     if (!TrackOpenShort) ResetTrack(OpenShort, TimeShort);
    
76. 
    
77.     O_Modify(OP_BUY);
    
78.     O_Modify(OP_SELL);
    
79. }
    
80. 
    
81. bool CheckOpenPosition(int positionSide) {
    
82.     double reference_price = positionSide == OP_BUY ? current_ask_price : current_bid_price;
    
83.     double last_open_price = positionSide == OP_BUY ? G_order_open_price_352 : G_order_open_price_360;
    
84.     return (positionSide == OP_BUY ? last_open_price - reference_price : reference_price - last_open_price) >= trade_batches[positionSide == OP_BUY ? long_index - 1 : short_index - 1].price_interval * Point;
    
85. }
    
86. 
    
87. void TryOpenPosition(int positionSide, int &index, bool &isOpen, datetime &trackTime) {
    
88.     if (index == 0 || isOpen && TimeCurrent() - trackTime >= sliptime * TimeSpanSeconds(M1)) {
    
89.         isOpen = true;
    
90.         double order_price = positionSide == OP_BUY ? Ask : Bid;
    
91.         int ticket = OrderSend(Symbol(), positionSide, trade_batches[positionSide == OP_BUY ? long_index : short_index].lot_size, order_price, slippage * Point, 0, 0, Commentt, MagicN, 0, positionSide == OP_BUY ? Blue : Red);
    
92.         if (ticket > 0) {
    
93.             isOpen = false;
    
94.             BuyOrSell = positionSide == OP_BUY ? TRUE : FALSE;
    
95.             index++;
    
96.         }
    
97.     }
    
98. }
    
99. 
    
100. void ResetTrack(bool &isOpen, datetime &trackTime) {
     
101.     isOpen = false;
     
102.     trackTime = 0;
     
103. }
     
104. 
     
105. // ... 保留原有的O_Modify函数和其他辅助函数 ...

复制代码

admin

这段代码已经更加接近完整可运行的状态，但仍然依赖于您原始代码中的某些未在该段代码中展示的变量，如 G_order_open_price_352 和 G_order_open_price_360 等。此外，还需要您在 EA 中实现 CountOrders 和 O_Modify 函数，以及其他必要的辅助函数。在实际使用前，请务必根据您的具体情况进行测试和调整。