MQL5教程 06 EA开发实战

于 2025-04-26 16:00:06 发布
阅读量330 收藏 5
点赞数 6
分类专栏： MQL5教程 文章标签： MQL5
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42830015/article/details/147358580
版权

文章目录

一、调用多指标多周期EA示例

shuju.mqh:

class shuju
  {
   public:
      shuju()
        {
        }     
      ~shuju()
        {
        }
      void MA(
         double &ma[],
         int count,
         string               symbol,            // 交易品种名称 
         ENUM_TIMEFRAMES      period,            // 周期 
         int                  ma_period,         // 平均周期 
         int                  ma_shift,          // 平移 
         ENUM_MA_METHOD       ma_method,         // 平滑类型 
         ENUM_APPLIED_PRICE   applied_price      // 价格或者处理程序类型 
        );
      void Bands( 
         double &Upper[],
         double &Lower[],
         double &Middle[],
         int count,
         string              symbol,            // 交易品种名称 
         ENUM_TIMEFRAMES     period,            // 周期 
         int                 bands_period,      // 平均线计算周期 
         int                 bands_shift,       // 指标平移 
         double              deviation,         // 标准差数 
         ENUM_APPLIED_PRICE  applied_price      // 价格或处理器类型 
        );
      void Stochastic( 
         double &data0[],
         double &data1[],
         int count,
         string           symbol,          // 交易品种名称 
         ENUM_TIMEFRAMES  period,          // 周期 
         int              Kperiod,         // K线周期 (用于计算的柱数) 
         int              Dperiod,         // D线周期 (开始平滑周期) 
         int              slowing,         // 最终平滑 
         ENUM_MA_METHOD   ma_method,       // 平滑类型 
         ENUM_STO_PRICE   price_field      // 随机计算法 
        );
      int getrates(MqlRates &rates[],int count,string symbol,ENUM_TIMEFRAMES tf);
  };

void shuju::MA(
   double               &ma[],
   int                  count,            // 复制总数
   string               symbol,           // 交易品种名称 
   ENUM_TIMEFRAMES      period,           // 周期 
   int                  ma_period,        // 平均周期 
   int                  ma_shift,         // 平移 
   ENUM_MA_METHOD       ma_method,        // 平滑类型 
   ENUM_APPLIED_PRICE   applied_price     // 价格或者处理程序类型 
  ){
  
   int ma_h = iMA(symbol,period,ma_period,ma_shift,ma_method,applied_price);
   ArraySetAsSeries(ma,true);
   CopyBuffer(ma_h,0,0,count,ma);
   IndicatorRelease(ma_h);
   
  }
  
void shuju::Bands( 
   double &Upper[],
   double &Lower[],
   double &Middle[],
   int count,
   string              symbol,            // 交易品种名称 
   ENUM_TIMEFRAMES     period,            // 周期 
   int                 bands_period,      // 平均线计算周期 
   int                 bands_shift,       // 指标平移 
   double              deviation,         // 标准差数 
   ENUM_APPLIED_PRICE  applied_price      // 价格或处理器类型 
  ){
  
   int h = iBands(symbol,period,bands_period,bands_shift,deviation,applied_price);
   ArraySetAsSeries(Upper, true);
   ArraySetAsSeries(Lower, true);
   ArraySetAsSeries(Middle, true);
   CopyBuffer(h,0,0,count,Middle);
   CopyBuffer(h,1,0,count,Upper);
   CopyBuffer(h,2,0,count,Lower);
   IndicatorRelease(h);
  }
  
void shuju::Stochastic( 
   double &data0[],
   double &data1[],
   int count,
   string           symbol,          // 交易品种名称 
   ENUM_TIMEFRAMES  period,          // 周期 
   int              Kperiod,         // K线周期 (用于计算的柱数) 
   int              Dperiod,         // D线周期 (开始平滑周期) 
   int              slowing,         // 最终平滑 
   ENUM_MA_METHOD   ma_method,       // 平滑类型 
   ENUM_STO_PRICE   price_field      // 随机计算法 
  ){
  
   int h = iStochastic(symbol,period,Kperiod,Dperiod,slowing,ma_method,price_field);
   ArraySetAsSeries(data0, true);
   ArraySetAsSeries(data1, true);
   CopyBuffer(h,0,0,count,data0);
   CopyBuffer(h,1,0,count,data1);
   IndicatorRelease(h);
  
  }
  
int shuju::getrates(MqlRates &rates[],int count,string symbol,ENUM_TIMEFRAMES tf)
  {
   ArraySetAsSeries(rates, true);
   return(CopyRates(symbol,tf,0,count,rates));
  }

jiaoyi.mqh:

class jiaoyi
  {
   public:
      ulong buy(string symbol,double lots,int slpoint,int tppoint,string com,int magic);
      ulong buyplus(string symbol,double lots,int slpoint,int tppoint,string com,int magic);
      ulong sell(string symbol,double lots,int slpoint,int tppoint,string com,int magic);
      ulong sellplus(string symbol,double lots,int slpoint,int tppoint,string com,int magic);
      void  closeallbuy(string symbol);
      void  closeallsell(string symbol);
  };
  
ulong jiaoyi::buy(string symbol,double lots,int slpoint,int tppoint,string com,int magic)
  {
   MqlTradeRequest request = {};
   MqlTradeResult  result  = {};
   request.action = TRADE_ACTION_DEAL;
   request.symbol = symbol;
   request.type   = ORDER_TYPE_BUY;
   request.volume = lots;
   request.deviation    = 100;
   request.type_filling = ORDER_FILLING_IOC;
   request.price        = SymbolInfoDouble(symbol,SYMBOL_ASK);
   // SYMBOL_TRADE_STOPS_LEVEL 设置止损/止盈时，与当前价格的最小距离限制（以点为单位）
   if(slpoint>SymbolInfoInteger(symbol,SYMBOL_TRADE_STOPS_LEVEL))
     {
      request.sl = SymbolInfoDouble(symbol,SYMBOL_ASK) - slpoint*SymbolInfoDouble(symbol,SYMBOL_POINT);
     }
   if(tppoint>SymbolInfoInteger(symbol,SYMBOL_TRADE_STOPS_LEVEL))
     {
      request.tp = SymbolInfoDouble(symbol,SYMBOL_ASK) + tppoint*SymbolInfoDouble(symbol,SYMBOL_POINT);
     }
   request.comment = com;
   request.magic   = magic;
   // --- 发送请求
   if(!OrderSend(request, result))
      PrintFormat("OrderSend error %d", GetLastError()); // 如果不能发送请求，输出错误代码
   // --- 显示操作信息
   PrintFormat("retcode=%u  deal=%I64u  order=%I64u",result.retcode,result.deal,result.order);
   
   return(result.order);
  }
  
ulong jiaoyi::buyplus(string symbol,double lots,int slpoint,int tppoint,string com,int magic)
  {
   ulong ticket = 0;
   int total = PositionsTotal();
   
   for(int i=total-1; i>=0; i--)
     {
      if(PositionGetTicket(i)>0)
        {
         if(PositionGetString(POSITION_SYMBOL)==symbol && PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_BUY && PositionGetInteger(POSITION_MAGIC)==magic && PositionGetString(POSITION_COMMENT)==com)
            return(0);
        }
     }
     
   ticket = buy(symbol,lots,slpoint,tppoint,com,magic);
   return(ticket);
  }
  
ulong jiaoyi::sell(string symbol,double lots,int slpoint,int tppoint,string com,int magic)
  {
   MqlTradeRequest request = {};
   MqlTradeResult  result  = {};
   request.action = TRADE_ACTION_DEAL;
   request.symbol = symbol;
   request.type   = ORDER_TYPE_SELL;
   request.volume = lots;
   request.deviation    = 100;
   request.type_filling = ORDER_FILLING_IOC;
   request.price        = SymbolInfoDouble(symbol,SYMBOL_BID);

   if(slpoint>SymbolInfoInteger(symbol,SYMBOL_TRADE_STOPS_LEVEL))
     {
      request.sl = SymbolInfoDouble(symbol,SYMBOL_BID) + slpoint*SymbolInfoDouble(symbol,SYMBOL_POINT);
     }
   if(tppoint>SymbolInfoInteger(symbol,SYMBOL_TRADE_STOPS_LEVEL))
     {
      request.tp = SymbolInfoDouble(symbol,SYMBOL_BID) - tppoint*SymbolInfoDouble(symbol,SYMBOL_POINT);
     }
   request.comment = com;
   request.magic   = magic;
   // --- 发送请求
   if(!OrderSend(request, result))
      PrintFormat("OrderSend error %d", GetLastError());
   // --- 显示操作信息
   PrintFormat("retcode=%u  deal=%I64u  order=%I64u",result.retcode,result.deal,result.order);
   
   return(result.order);
  }
  
ulong jiaoyi::sellplus(string symbol,double lots,int slpoint,int tppoint,string com,int magic)
  {
   ulong ticket = 0;
   int total = PositionsTotal();
   
   for(int i=total-1; i>=0; i--)
     {
      if(PositionGetTicket(i)>0)
        {
         if(PositionGetString(POSITION_SYMBOL)==symbol && PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_SELL && PositionGetInteger(POSITION_MAGIC)==magic && PositionGetString(POSITION_COMMENT)==com)
            return(0);
        }
     }
     
   ticket = sell(symbol,lots,slpoint,tppoint,com,magic);
   return(ticket);
  }
  
void jiaoyi::closeallbuy(string symbol)
  {
   int total = PositionsTotal();
   for(int i=total-1; i>=0; i--)
     {
      ulong ticket = PositionGetTicket(i);
      if(ticket>0)
        {
         if(PositionGetString(POSITION_SYMBOL)==symbol && PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_BUY)
           {
            MqlTradeRequest request = {};
            MqlTradeResult  result  = {};
            request.action   = TRADE_ACTION_DEAL;                    // 交易操作类型
            request.symbol   = symbol;                               // 交易品种
            request.volume   = PositionGetDouble(POSITION_VOLUME);   // 交易量 
            request.type     = ORDER_TYPE_SELL;                      // 订单类型
            request.price    = SymbolInfoDouble(symbol,SYMBOL_BID);  // 持仓价格
            request.deviation= 100;                                  // 允许价格偏差
            request.type_filling=ORDER_FILLING_IOC;
            request.position = ticket;
            
            if(!OrderSend(request,result))
               PrintFormat("OrderSend error %d",GetLastError()); 
           }
        }
     }
  }
  
void jiaoyi::closeallsell(string symbol)
  {
   int total = PositionsTotal();
   for(int i=total-1; i>=0; i--)
     {
      ulong ticket = PositionGetTicket(i);
      if(ticket>0)
        {
         if(PositionGetString(POSITION_SYMBOL)==symbol && PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_SELL)
           {
            MqlTradeRequest request = {};
            MqlTradeResult  result  = {};
            request.action   = TRADE_ACTION_DEAL;                    // 交易操作类型
            request.symbol   = symbol;                               // 交易品种
            request.volume   = PositionGetDouble(POSITION_VOLUME);   // 交易量 
            request.type     = ORDER_TYPE_BUY;                       // 订单类型
            request.price    = SymbolInfoDouble(symbol,SYMBOL_ASK);  // 持仓价格
            request.deviation= 100;                                  // 允许价格偏差
            request.type_filling=ORDER_FILLING_IOC;
            request.position = ticket;
            
            if(!OrderSend(request,result))
               PrintFormat("OrderSend error %d",GetLastError()); 
           }
        }
     }
  }

EA:

#include <myClass/jiaoyi.mqh>
#include <myClass/shuju.mqh>

jiaoyi jy;
shuju  sj;

input double LOTS  = 0.01;    // 开仓手数
input int sl_point = 700;    // 止损点数
input int tp_point = 700;    // 止盈点数
input int MAGIC    = 12345;   // 幻数
input int little_period = 5;  // 小均线周期
input int large_period  = 10; // 大均线周期
input int bollinger_period  = 20;   // 布林带周期
input double bollinger_deviation = 2; // 布林带偏差
input int InpKPeriod = 5; // K period
input int InpDPeriod = 3; // D period
input int InpSlowing = 3; // Slowing

int OnInit()
  {
   return(INIT_SUCCEEDED);
  }

void OnDeinit(const int reason)
  {
   
  }

void OnTick()
  {
   double m30_ma_xiao[];   // 30分钟小周期MA
   sj.MA(m30_ma_xiao,4,Symbol(),PERIOD_M30,little_period,0,MODE_SMA,PRICE_CLOSE);
   double m30_ma_da[];     // 30分钟大周期MA
   sj.MA(m30_ma_da,4,Symbol(),PERIOD_M30,large_period,0,MODE_SMA,PRICE_CLOSE);
   
   double h4_ma_xiao[];    // H4小周期MA
   sj.MA(h4_ma_xiao,4,Symbol(),PERIOD_H4,little_period,0,MODE_SMA,PRICE_CLOSE);
   double h4_ma_da[];      // H4大周期MA
   sj.MA(h4_ma_da,4,Symbol(),PERIOD_H4,large_period,0,MODE_SMA,PRICE_CLOSE);
   
   double m30_bands_up[], m30_bands_low[], m30_bands_mid[];
   sj.Bands(m30_bands_up,m30_bands_low,m30_bands_mid,4,Symbol(),PERIOD_M30,bollinger_period,0,bollinger_deviation,PRICE_CLOSE);
   double h4_bands_up[], h4_bands_low[], h4_bands_mid[];
   sj.Bands(h4_bands_up,h4_bands_low,h4_bands_mid,4,Symbol(),PERIOD_H4,bollinger_period,0,bollinger_deviation,PRICE_CLOSE);
  
   double m30_k[], m30_d[];
   sj.Stochastic(m30_k,m30_d,4,Symbol(),PERIOD_M30,InpKPeriod,InpDPeriod,InpSlowing,MODE_SMA,STO_LOWHIGH);
   double h4_k[], h4_d[];
   sj.Stochastic(h4_k,h4_d,4,Symbol(),PERIOD_H4,InpKPeriod,InpDPeriod,InpSlowing,MODE_SMA,STO_LOWHIGH);
   
   MqlRates m30_rate[];
   sj.getrates(m30_rate,4,Symbol(),PERIOD_M30);
   MqlRates h4_rate[];
   sj.getrates(h4_rate,4,Symbol(),PERIOD_H4);
   
   // 开多单：H4K线下穿布林带下轨，且M30小周期均线在大周期均线之上，且M30指标KDJ金叉
   if(h4_rate[0].low<h4_bands_low[0] && m30_ma_xiao[0]>m30_ma_da[0] && m30_k[1]>m30_d[1] && m30_k[2]<m30_d[2])
      jy.buyplus(Symbol(),LOTS,sl_point,tp_point,"buy",MAGIC);
   // 平仓多单：在M30指标KDJ死叉
   if(m30_k[1]<m30_d[1] && m30_k[2]>m30_d[2])
      jy.closeallbuy(Symbol());
   
   // 开空单
   if(h4_rate[0].high>h4_bands_up[0] && m30_ma_xiao[0]<m30_ma_da[0] && m30_k[1]<m30_d[1] && m30_k[2]>m30_d[2])
      jy.sellplus(Symbol(),LOTS,sl_point,tp_point,"sell",MAGIC);   
   // 平仓空单
   if(m30_k[1]>m30_d[1] && m30_k[2]<m30_d[2])
      jy.closeallsell(Symbol());
   
  }

二、获取ZigZag顶点值

shuju.mqh：

class shuju
  {
   public:
      shuju()
        {
        }     
      ~shuju()
        {
        }
      void ZigZag(double &data0[],int count,ENUM_TIMEFRAMES period,int ExtDepth,int ExtDeviation,int ExtBackstep);
      void gettime(datetime &time[],int count);
      void getlow(double &Low[],int count);
  };

void shuju::ZigZag(double &data0[],int count,ENUM_TIMEFRAMES period,int ExtDepth,int ExtDeviation,int ExtBackstep)
  {
   int h = iCustom(Symbol(),period,"Examples/ZigZag",ExtDepth,ExtDeviation,ExtBackstep);
   ArraySetAsSeries(data0,true);
   CopyBuffer(h,0,0,count,data0);
   IndicatorRelease(h);
  }
  
void shuju::gettime(datetime &time[],int count)
  {
   ArraySetAsSeries(time,true);
   CopyTime(Symbol(),0,0,count,time);
  }
  
void shuju::getlow(double &Low[],int count)
  {
   ArraySetAsSeries(Low,true);
   CopyLow(Symbol(),0,0,count,Low);
  }

EA：

#include <myClass/shuju.mqh>

shuju  sj;

input int InpDepth    =12;  // Depth
input int InpDeviation=5;   // Deviation
input int InpBackstep =3;   // Back Step
input int geshu = 10;

double zigzag[][4];   // 只计入顶点值

int OnInit()
  {
   ArrayResize(zigzag, geshu);   // 设置新的第一维大小
   return(INIT_SUCCEEDED);
  }

void OnDeinit(const int reason)
  {
   
  }

void OnTick()
  {
   // ZigZag指标的顶点值为对应K线的最高/最低价，非顶点值为0
   double zigzagzhi[];
   int bars = Bars(Symbol(),0);  // 返回K嫌数量
   sj.ZigZag(zigzagzhi,bars,PERIOD_CURRENT,InpDepth,InpDeviation,InpBackstep);
   datetime time[];
   sj.gettime(time, bars);
   double low[];
   sj.getlow(low, bars);

   int counter = 0;
   for(int i=0; i<bars; i++)
     {
      if(counter>(geshu-1))
        {
         break;
        }
      if(zigzagzhi[i]>0)
        {
         zigzag[counter][0] = zigzagzhi[i];
         zigzag[counter][1] = i;
         zigzag[counter][2] = (double)time[i];
         if(zigzagzhi[i] <= low[i]) // 低点
           {
            zigzag[counter][3] = 1;
           }
         else  // 高点
           {
            zigzag[counter][3] = 2;
           }
         counter++;
        }
     }
  }

三、逆势加仓EA

jiaoyi.mqh：

class jiaoyi
  {
   public:
      int danshu(string symbol,ENUM_POSITION_TYPE type);
      ulong buy(string symbol,double lots,int slpoint,int tppoint,string com,int magic);
      ulong buyplus(string symbol,double lots,int slpoint,int tppoint,string com,int magic);
      ulong zuijindan(string symbol,ENUM_POSITION_TYPE type,double &openprice,datetime &opentime,double &openlots,double &opensl,double &opentp,int magic);
      double formatlots(string symbol,double lots);
      void modifysltp(ENUM_POSITION_TYPE type,double sl,double tp);
  };
  
int jiaoyi::danshu(string symbol,ENUM_POSITION_TYPE type)
  {
   int count = 0;
   int total = PositionsTotal();
   for(int i=total-1; i>=0; i--)
     {
      ulong ticket = PositionGetTicket(i);
      if(ticket > 0)
        {
         if(PositionGetString(POSITION_SYMBOL)==symbol && PositionGetInteger(POSITION_TYPE)==type)
            count++;
        }
     }
     
   return(count);
  }
  
ulong jiaoyi::buy(string symbol,double lots,int slpoint,int tppoint,string com,int magic)
  {
   MqlTradeRequest request = {};
   MqlTradeResult  result  = {};
   request.action = TRADE_ACTION_DEAL;
   request.symbol = symbol;
   request.type   = ORDER_TYPE_BUY;
   request.volume = lots;
   request.deviation    = 100;
   request.type_filling = ORDER_FILLING_IOC;
   request.price        = SymbolInfoDouble(symbol,SYMBOL_ASK);
   // SYMBOL_TRADE_STOPS_LEVEL 设置止损/止盈时，与当前价格的最小距离限制（以点为单位）
   if(slpoint>SymbolInfoInteger(symbol,SYMBOL_TRADE_STOPS_LEVEL))
     {
      request.sl = SymbolInfoDouble(symbol,SYMBOL_ASK) - slpoint*SymbolInfoDouble(symbol,SYMBOL_POINT);
     }
   if(tppoint>SymbolInfoInteger(symbol,SYMBOL_TRADE_STOPS_LEVEL))
     {
      request.tp = SymbolInfoDouble(symbol,SYMBOL_ASK) + tppoint*SymbolInfoDouble(symbol,SYMBOL_POINT);
     }
   request.comment = com;
   request.magic   = magic;
   // --- 发送请求
   if(!OrderSend(request, result))
      PrintFormat("OrderSend error %d", GetLastError()); // 如果不能发送请求，输出错误代码
   // --- 显示操作信息
   PrintFormat("retcode=%u  deal=%I64u  order=%I64u",result.retcode,result.deal,result.order);
   
   return(result.order);
  }
  
ulong jiaoyi::buyplus(string symbol,double lots,int slpoint,int tppoint,string com,int magic)
  {
   ulong ticket = 0;
   int total = PositionsTotal();
   
   for(int i=total-1; i>=0; i--)
     {
      if(PositionGetTicket(i)>0)
        {
         if(PositionGetString(POSITION_SYMBOL)==symbol && PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_BUY && PositionGetInteger(POSITION_MAGIC)==magic && PositionGetString(POSITION_COMMENT)==com)
            return(0);
        }
     }
     
   ticket = buy(symbol,lots,slpoint,tppoint,com,magic);
   return(ticket);
  }
  
ulong jiaoyi::zuijindan(string symbol,ENUM_POSITION_TYPE type,double &openprice,datetime &opentime,double &openlots,double &opensl,double &opentp,int magic=0)
  {
   openprice = 0;
   opentime  = 0;
   openlots  = 0;
   opensl    = 0;
   opentp    = 0;
   ulong ticket = 0;
   int   total  = PositionsTotal();
   for(int i=total; i>=0; i--)
     {
      if(PositionGetTicket(i) > 0)
         {
            if(PositionGetString(POSITION_SYMBOL)==symbol && PositionGetInteger(POSITION_TYPE)==type && PositionGetInteger(POSITION_MAGIC)==magic)
              {
                 openprice=PositionGetDouble(POSITION_PRICE_OPEN);
                 opentime=(datetime)PositionGetInteger(POSITION_TIME);
                 openlots=PositionGetDouble(POSITION_VOLUME);
                 opensl=PositionGetDouble(POSITION_SL);
                 opentp=PositionGetDouble(POSITION_TP);
                 ticket=PositionGetInteger(POSITION_TICKET);
                 break;
              }
         }
     }
     
   return(ticket);
  }
  
double jiaoyi::formatlots(string symbol,double lots)
  {
   double final_lots = 0;
   double minilots=SymbolInfoDouble(symbol,SYMBOL_VOLUME_MIN);
   double steplots=SymbolInfoDouble(symbol,SYMBOL_VOLUME_STEP);
   
   if(lots<minilots)
      return(0);
   else
     {
      double temp = MathFloor(lots/minilots)*minilots;
      final_lots  = temp + MathFloor((lots-temp)/steplots)*steplots;
     }
   
   return(final_lots);
  }
  
void jiaoyi::modifysltp(ENUM_POSITION_TYPE type,double sl,double tp)
  {
   int total = PositionsTotal();
   for(int i=total-1; i>=0; i--)
     {
      if(PositionGetTicket(i)>0)
        {
         if(type==POSITION_TYPE_BUY)
           {
            // 止损止盈不等于原单子，才做修改。
            if((NormalizeDouble(sl,(int)SymbolInfoInteger(Symbol(),SYMBOL_DIGITS))!=NormalizeDouble(PositionGetDouble(POSITION_SL),(int)SymbolInfoInteger(Symbol(),SYMBOL_DIGITS))||NormalizeDouble(tp,(int)SymbolInfoInteger(Symbol(),SYMBOL_DIGITS))!=NormalizeDouble(PositionGetDouble(POSITION_TP),(int)SymbolInfoInteger(Symbol(),SYMBOL_DIGITS))))
              {
               MqlTradeRequest request= {};
               MqlTradeResult  result = {};
               request.action   = TRADE_ACTION_SLTP;
               request.position = PositionGetTicket(i);
               request.symbol   = Symbol();
               request.sl       = NormalizeDouble(sl,(int)SymbolInfoInteger(Symbol(),SYMBOL_DIGITS));
               request.tp       = NormalizeDouble(tp,(int)SymbolInfoInteger(Symbol(),SYMBOL_DIGITS));
               if(sl<0)
                  request.sl = NormalizeDouble(PositionGetDouble(POSITION_SL),(int)SymbolInfoInteger(Symbol(),SYMBOL_DIGITS));
               if(tp<0)
                  request.tp = NormalizeDouble(PositionGetDouble(POSITION_TP),(int)SymbolInfoInteger(Symbol(),SYMBOL_DIGITS));
               if(!OrderSend(request,result))
                  PrintFormat("OrderSend error %d",GetLastError());
              }
           }
         if(type==POSITION_TYPE_SELL)
           {
            if((NormalizeDouble(sl,(int)SymbolInfoInteger(Symbol(),SYMBOL_DIGITS))!=NormalizeDouble(PositionGetDouble(POSITION_SL),(int)SymbolInfoInteger(Symbol(),SYMBOL_DIGITS))||NormalizeDouble(tp,(int)SymbolInfoInteger(Symbol(),SYMBOL_DIGITS))!=NormalizeDouble(PositionGetDouble(POSITION_TP),(int)SymbolInfoInteger(Symbol(),SYMBOL_DIGITS))))
              {
               MqlTradeRequest request= {};
               MqlTradeResult  result = {};
               request.action   = TRADE_ACTION_SLTP;
               request.position = PositionGetTicket(i);
               request.symbol   = Symbol();
               request.sl       = NormalizeDouble(sl,(int)SymbolInfoInteger(Symbol(),SYMBOL_DIGITS));
               request.tp       = NormalizeDouble(tp,(int)SymbolInfoInteger(Symbol(),SYMBOL_DIGITS));
               if(sl<0)
                  request.sl = NormalizeDouble(PositionGetDouble(POSITION_SL),(int)SymbolInfoInteger(Symbol(),SYMBOL_DIGITS));
               if(tp<0)
                  request.tp = NormalizeDouble(PositionGetDouble(POSITION_TP),(int)SymbolInfoInteger(Symbol(),SYMBOL_DIGITS));
               if(!OrderSend(request,result))
                  PrintFormat("OrderSend error %d",GetLastError());
                 }
           }
        }
     }
  }

shuju.mqh：

class shuju
  {
   public:
      shuju()
        {
        }     
      ~shuju()
        {
        }
      void getrates(MqlRates &rates[],int count);
      void shuju::Bands( 
         double &Upper[],
         double &Lower[],
         double &Middle[],
         int count,
         string              symbol,            // 交易品种名称 
         ENUM_TIMEFRAMES     period,            // 周期 
         int                 bands_period,      // 平均线计算周期 
         int                 bands_shift,       // 指标平移 
         double              deviation,         // 标准差数 
         ENUM_APPLIED_PRICE  applied_price      // 价格或处理器类型 
        );
      double getask();
  };

void shuju::getrates(MqlRates &rates[],int count)
  {
   ArraySetAsSeries(rates, true);
   CopyRates(Symbol(),PERIOD_CURRENT,0,count,rates);
  }
  
void shuju::Bands( 
   double &Upper[],
   double &Lower[],
   double &Middle[],
   int count,
   string              symbol,            // 交易品种名称 
   ENUM_TIMEFRAMES     period,            // 周期 
   int                 bands_period,      // 平均线计算周期 
   int                 bands_shift,       // 指标平移 
   double              deviation,         // 标准差数 
   ENUM_APPLIED_PRICE  applied_price      // 价格或处理器类型 
  ){
  
   int h = iBands(symbol,period,bands_period,bands_shift,deviation,applied_price);
   ArraySetAsSeries(Upper, true);
   ArraySetAsSeries(Lower, true);
   ArraySetAsSeries(Middle, true);
   CopyBuffer(h,0,0,count,Middle);
   CopyBuffer(h,1,0,count,Upper);
   CopyBuffer(h,2,0,count,Lower);
   IndicatorRelease(h);
  }
  
double shuju::getask()
  {
   return(SymbolInfoDouble(Symbol(),SYMBOL_ASK));
  }

EA：

#include <myClass/jiaoyi.mqh>
#include <myClass/shuju.mqh>

jiaoyi jy;
shuju  sj;

input double init_lots = 0.1; // 初始下单量
input int    loss_add_interbal_point = 100;  // 亏损加仓间隔点数
input double loss_add_multiple = 2; // 亏损加仓下单倍数
input int    syn_add_max_times = 5; // 同向单最多加仓次数
input int    call_back_tp_point = 200; // 回调止盈点数
input int    bollinger_period = 20;
input double bollinger_deviation =2;
input int    MAGIC = 12345;

datetime buytime=0;
MqlRates rate[];

int OnInit()
  {
   sj.getrates(rate, 4);
   buytime = rate[0].time;
   return(INIT_SUCCEEDED);
  }

void OnDeinit(const int reason)
  {
   
  }

void OnTick()
  {
   // 这里只展示开多单部分
   sj.getrates(rate, 4);
   double bandsup[], bandslow[], bandsmid[];
   sj.Bands(bandsup,bandslow,bandsmid,4,Symbol(),PERIOD_CURRENT,bollinger_period,0,bollinger_deviation,PRICE_CLOSE);
   int buydanshu = jy.danshu(Symbol(), POSITION_TYPE_BUY);
   // 条件 buytime!=rate[0].time 是为了一根K线只开一个单。
   if(buydanshu==0)
     {
      // 上一根K线的开盘价收盘价均脱离布林带下轨，且再上一根K线最低价触碰到布林带下轨，则开多单。
      if(buytime!=rate[0].time && rate[1].open>bandslow[1] && rate[1].close>bandslow[1] && rate[2].low<bandslow[2])
      {
         if(jy.buyplus(Symbol(),init_lots,0,call_back_tp_point,"buy",MAGIC) > 0)
            buytime = rate[0].time;
      }
     }
   else
     {
      double open_price, open_lots, open_sl, open_tp;
      datetime open_time;
      jy.zuijindan(Symbol(),POSITION_TYPE_BUY,open_price,open_time,open_lots,open_sl,open_tp,MAGIC);
      // 修改此前所有单的止盈价为最后一单的止盈价
      jy.modifysltp(POSITION_TYPE_BUY, -1, open_tp); // 止损设为负值，则表示不修改止损
      if(buydanshu<=syn_add_max_times && (open_price-sj.getask()) >= loss_add_interbal_point*Point())
        {
         // 逆势加仓
         jy.buyplus(Symbol(),jy.formatlots(Symbol(), open_lots*loss_add_multiple),0,call_back_tp_point,"buy"+IntegerToString(buydanshu),MAGIC);
        }
     }
  }
利用 MQL5 面向对象编程法编写“EA 交易“
JanLEE
07-31 634
简介 通过第一篇文章，我们从整体上了解了 MQL5 中某“EA 交易”创建、调试及测试的基本步骤。 我们做过的每一件事都非常简单且有趣；但是，新的 MQL5 语言的功能还远远不止于此。 而在本文中，我们则会探讨面向对象法，将我们曾在第一篇文章中谈到的内容落到实处。 很多人都觉得难，但是，我向您保证，看完本文之后，您就能够编写自己的面向对象 “EA 交易”了。 我们不会重复第一篇文章中学过的某些内容，所以，如果您没读过，则建议您首先通读该文。 1. 面向对象范式 新型 MQL5 之所以比 MQL
MQL5 初学者：EA 交易技术指标使用指南
JanLEE
07-23 1506
简介 很少有“EA 交易”或指标未在代码中使用标准技术指标。无论是对交易策略的初学者还是高级开发人员，这些标准技术指标的使用都十分普遍。指标创建 的各种细节并不难理解；本文的目的即是帮助理解。我们将考虑使用内置标准技术指标的函数。 使用标准技术指标函数的基础 在调用时，每个技术指标函数创建一个使用指定的输入参数创 建的对象（指标的实例）的处理函数。处理函数的目的是使用该对象对其进行分配。这足以从指标缓冲区获取数据并将其用于自己的计算。考虑以下示例： doubleMA[];...
MQL5 双均线EA 源码
01-24
自己写的一个MQL5 的EA程序。采用面向对象的设计，可以用来作为EA程序模板。有需要的朋友可以自己改下指标对象的买卖条件就可以了
【EA教程】——ER图生成数据库
热门推荐
全力奔跑，梦在彼岸
07-31 1万+
【背景】 在做第二遍机房的时候就用到了EA(Enterprise Architect)——UML软件开发与建模工具，顾名思义知道EA是用来画软件开发各阶段的图的工具，当时用EA画了各种时序图、类图、包图、状态图等等，觉得自己已经会用这个软件了，后来跟伙伴交流才发现，EA的功能还有很多，需要我们对问题不将就地去解决，发现新的契机，从不熟悉发展为熟悉，站在巨人的肩膀上，利用好EA，让其更好的地为我们
MQL5:在EA和脚本程序中引用自定义指标
liangzixx的博客
11-07 6295
MT5:在EA和脚本程序中引用指标第一步 声明第二步 使用 iCustom 函数 最近刚对MQL5语言有一点了解。 在写指标、EA的时候可以参考的、有用的资料除了MQL5自带的参考，能百度到的实在是少之又少。 也可能是我自己找到资料的能力有限。 今天通过看MQL5自带的参考文档，在脚本和EA中得到了想要的指标计算值。 果然多看看参考文档是没有错的。 那废话不说，看看我是怎么做的吧。 大致分为三步 ...
MQL5源码：智能交易脚本EA结构解读
04-12 1万+
EA是MQL中的自动交易脚本，可以通过编程控制计算机自动进行交易，节省人工盯盘的精力，以及提高执行效率。 本文以经典的均线交易系统解读MQL5交易脚本EA的结构。 策略当价格上穿均线时做多并在下穿均线时平仓；当价格下穿均线时做空并在上穿均线时平仓。 真是非常简单的均线交易系统呢。代码结构精解版本声明在一开始，会有一些跟实际功能无关的代码，大致是一个EA的自我介绍的玩意，并没有什么功能上的用途
MQL5 简介：如何编写简单的EA 交易和自定义指标
JanLEE
07-23 2465
简介 相比 MQL4，MetaTrader 5 客户端的 MetaQuotes 编程语言 5 (MQL5) 具有许多新的发展潜力和更高的性能。本文将帮助您熟悉这一新的编程语言。文中给出了编写“EA 交易”和自定义指标的简单示例。我们还会涉及到 MQL5 语言的一些细节，这些细节对于理解示例是必要的。 文章细节和 MQL5 语言的完整说明可在 MetaTrader 5 中包含的MQL5 参考中找到。MQL 5 内置的“帮助”内容足以帮助您学习本语言。本文对于那些熟悉 MQL4 以及那些刚刚涉足交易系统和.
针对初学者以_MQL5_编写“EA_交易”的分步指南_-_MQL5文章
11-21
针对初学者以_MQL5_编写“EA_交易”的分步指南_-_MQL5文章
处理 MQL5“EA 交易”的 GSM 调制解调器
JanLEE
08-23 376
简介 当前，有相当数量的方式可以对交易账户进行轻松的远程监视：移动终端、推送通知、ICQ 。但都需要互联网连接。本文描述了“EA 交易”的创建程序，即使在移动互联网不可用的情况下，其也允许您通过电话或短信与交易终端保持联系。此外，在与交易服务器失去连接或重新建立连接时，该“EA 交易”将能够通知您。 几乎任何 GSM 调制解调器，以及带调制解调器功能的大多数手机均可实现该目标。例如，我选择Huawei E1550，该调制解调器是同类产品中应用范围最广的产品之一。此外，在本文结尾处，我们将尝试用旧款手机.
MQL5智能EA指标脚本开发实战指南
MT5智能交易之路：MQL5智能EA指标脚本开发的知识点涵盖了交易策略、智能交易、编程语言MQL5、自动化交易、MT5外汇交易等多个方面。本文将详细介绍这些知识点，以帮助读者全面掌握MQL5在智能EA（Expert Advisors，...
MT4 EA 编写中高级教程
06-01
MT4 EA 编写中高级教程 MT4 EA 编写中高级教程
EA教程
03-18
NULL 博文链接：https://andilyliao.iteye.com/blog/686764
MT4EA编程教程
06-27
EA编程教程
EA编写教程.rar_EA学习_EA编写教程2019_EA编程 PDF_beginning9rt_ea 学习
07-15
ea编写教程,初学者可以看看学习。内含初级和中级教程
MQL4高级培训教程,mql4编程教程
09-10
**MQL4高级培训教程详解** MQL4是MetaQuotes Language 4的简称，它是MetaTrader 4交易平台的编程语言，用于创建自定义技术指标、交易机器人（EA交易）以及脚本。本教程针对已有一定MQL4基础的学员，旨在深入探讨其...
使用MQL4编写外汇对冲套利EA的小资金账户实战教程
最新发布
m0_57781768的博客
06-25 1307
对冲套利是一种通过在不同市场或不同资产之间建立相对风险对冲头寸，以实现无风险或低风险利润的交易策略。其核心在于利用市场的不均衡，买入相对低估的资产，同时卖出相对高估的资产，从而在市场回归均衡时获利。MQL4（MetaQuotes Language 4）是MetaTrader 4交易平台的编程语言，用于编写交易策略（EA）、自定义指标和脚本。MQL4具有类似于C语言的语法结构，易于学习和使用。在EA代码的开头，定义相关的参数和变量，包括货币对、交易量、止损止盈等。// 参数定义// 第一个货币对。
MQL4初级培训教程_mql4_
09-30
**MQL4初级培训教程** MQL4是MetaQuotes Language 4的缩写，是MetaTrader 4交易平台用于编写交易机器人、技术指标和脚本的编程语言。这个初级培训教程旨在帮助初学者理解和掌握MQL4的基础知识，以便在外汇市场进行...
MQL4 EA与MT4编程培训教程大全
- **EA教材**：重点教授EA开发的各个方面，包括算法的逻辑设计、风险控制、资金管理策略和性能测试。 ### 自动化交易实战 - **策略开发**：学习如何根据交易理念开发出完整的交易策略，并转换成EA代码。 - **回测与...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值