无持仓情况下挂单多空交易策略代码优化及完整实现

该代码实现了一种无持仓情况下同时挂单多单和空单的交易策略，并在策略初始化时执行策略主函数。以下为完整的代码：

extern int magicNumber = 92133; // 魔术码
extern double initialLots = 0.5; // 初始手数
extern int interval = 100; // 间距
extern double replenishmentMultiplier = 0.6; // 补仓倍数
extern int maxReplenishmentCount = 5; // 补仓次数
extern double takeProfitAmount = 80; // 止盈金额

int totalOrders = 0; // 总订单数
int buyOrders = 0; // 多单订单数
int sellOrders = 0; // 空单订单数
double lastBuyOrderPrice = 0; // 最后一个多单的持仓价
double lastSellOrderPrice = 0; // 最后一个空单的持仓价

// 开仓函数
void OpenOrder(double lots, int type) {
   double price = Ask; // 当前最新价
   if (type == OP_BUY) {
      lastBuyOrderPrice = price;
      buyOrders++;
   } else if (type == OP_SELL) {
      lastSellOrderPrice = price;
      sellOrders++;
   }
   totalOrders++;
   
   OrderSend(Symbol(), type, lots, price, 3, 0, 0, 'MagicNumber', magicNumber, 0, Green);
}

// 平仓函数
void CloseOrder(int ticket) {
   OrderClose(ticket, OrderLots(), OrderClosePrice(), 3, Red);
   totalOrders--;
   if (OrderType() == OP_BUY)
      buyOrders--;
   else if (OrderType() == OP_SELL)
      sellOrders--;
}

// 补仓函数
void ReplenishOrder(int type) {
   double lots = OrderLots() * replenishmentMultiplier;
   if (type == OP_BUY && buyOrders < maxReplenishmentCount)
      OpenOrder(lots, OP_BUY);
   else if (type == OP_SELL && sellOrders < maxReplenishmentCount)
      OpenOrder(lots, OP_SELL);
}

// 策略主函数
void OnTick() {
   double price = Ask; // 当前最新价
   int orders = OrdersTotal(); // 当前订单数
   
   // 判断持仓多单没有空单，并且最新价小于目前持仓中第一个多单持仓价100点时（间距），以初始手数0.5手做空，多空共存
   if (buyOrders > 0 && sellOrders == 0 && price < lastBuyOrderPrice - interval) {
      CloseAllOrders();
      OpenOrder(initialLots, OP_SELL);
   }
   
   // 判断持仓多单没有空单，并且最新价大于目前持仓中第一个空单持仓价100点时（间距），则以初始手数0.5手做多，多空共存
   if (buyOrders > 0 && sellOrders == 0 && price > lastSellOrderPrice + interval) {
      CloseAllOrders();
      OpenOrder(initialLots, OP_BUY);
   }
   
   // 检查止盈金额是否达到阈值，如果达到则触发全部平仓
   double totalProfit = 0;
   for (int i = 0; i < orders; i++) {
      if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) {
         if (OrderMagicNumber() == magicNumber)
            totalProfit += OrderProfit();
      }
   }
   if (totalProfit >= takeProfitAmount)
      CloseAllOrders();
   
   // 需要开仓逻辑
   if (totalOrders == 0) {
      // 根据最新价格加200点挂单一次多单
      double buyStopPrice = NormalizeDouble(price + 200 * Point, Digits);
      OrderSend(Symbol(), OP_BUYSTOP, initialLots, buyStopPrice, 3, 0, 0, 'MagicNumber', magicNumber, 0, Blue);
      
      // 根据最新价格减200点挂单一次空单
      double sellStopPrice = NormalizeDouble(price - 200 * Point, Digits);
      OrderSend(Symbol(), OP_SELLSTOP, initialLots, sellStopPrice, 3, 0, 0, 'MagicNumber', magicNumber, 0, Red);
   }
   
   // 检查挂单的多单成交
   if (buyOrders == 1 && sellOrders == 1) {
      if (OrderSelect(0, SELECT_BY_POS, MODE_TRADES) && OrderMagicNumber() == magicNumber && OrderType() == OP_BUYSTOP) {
         // 删除挂单的空单
         CloseOrder(OrderTicket());
         
         double currentLots = initialLots;
         double currentPrice = lastBuyOrderPrice;
         int replenishmentCount = 0;
         
         // 根据最新价格每间隔100点开仓一次多单
         while (price - currentPrice >= interval && replenishmentCount < maxReplenishmentCount) {
            replenishmentCount++;
            currentLots *= replenishmentMultiplier;
            currentPrice += interval;
            OpenOrder(currentLots, OP_BUY);
         }
      }
   }
   
   // 检查挂单的空单成交
   if (buyOrders == 1 && sellOrders == 1) {
      if (OrderSelect(0, SELECT_BY_POS, MODE_TRADES) && OrderMagicNumber() == magicNumber && OrderType() == OP_SELLSTOP) {
         // 删除挂单的多单
         CloseOrder(OrderTicket());
         
         double currentLots = initialLots;
         double currentPrice = lastSellOrderPrice;
         int replenishmentCount = 0;
         
         // 根据最新价格每间隔100点开仓一次空单
         while (currentPrice - price >= interval && replenishmentCount < maxReplenishmentCount) {
            replenishmentCount++;
            currentLots *= replenishmentMultiplier;
            currentPrice -= interval;
            OpenOrder(currentLots, OP_SELL);
         }
      }
   }
}

// 平掉所有订单
void CloseAllOrders() {
   int orders = OrdersTotal();
   for (int i = orders - 1; i >= 0; i--) {
      if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) {
         if (OrderMagicNumber() == magicNumber)
            CloseOrder(OrderTicket());
      }
   }
}

// 初始化函数
void OnInit() {
   totalOrders = 0;
   buyOrders = 0;
   sellOrders = 0;
   lastBuyOrderPrice = 0;
   lastSellOrderPrice = 0;
   OnTick(); // 初始化时执行一次策略主函数
}

// 入口点函数
void start() {
   OnTick();
}

代码说明:

• 该代码实现了无持仓的情况下同时挂单多单和空单，并包含止盈和补仓功能。
• 策略初始化时执行一次策略主函数 OnTick()，用于挂单。
• OpenOrder() 函数用于开仓，CloseOrder() 函数用于平仓，ReplenishOrder() 函数用于补仓。
• OnTick() 函数包含了主要的交易逻辑，例如判断是否需要开仓、平仓或补仓，以及止盈判断。
• CloseAllOrders() 函数用于平掉所有订单。

使用注意事项:

• 此代码仅实现了您提供的设定，并不包含完整的交易策略。
• 在实际应用中，您可能需要添加其他逻辑、风险管理和错误处理等代码。
• 在使用此代码之前，请做好充分的测试和验证。

代码优化建议:

• 可以使用更清晰的变量命名。
• 可以将代码拆分为更小的函数，提高代码可读性和可维护性。
• 可以添加更多的注释，帮助理解代码。
• 可以考虑使用更加完善的风险管理策略。

其他补充说明:

• 该代码需要在 MetaTrader 平台上运行。
• 您可以根据自己的需求修改代码中的参数，例如初始手数、间距、补仓倍数等。
• 在使用此代码进行交易之前，请务必进行充分的测试和验证，并根据实际情况调整策略参数和代码逻辑。