EA交易成本深度解析与优化实战

//+------------------------------------------------------------------+
//|                                              CostTracker.mqh     |
//|                        交易成本追踪器 - CTransactionCostTracker   |
//|  功能：统计点差、佣金、隔夜利息、滑点，支持逐笔记录和汇总输出       |
//+------------------------------------------------------------------+
#property copyright "晓辉编程"
#property link      "https://eafxtech.com"

// 单条成本记录结构体
struct SDealCostRecord
{
   long          deal_ticket;      // 成交单号
   datetime      deal_time;        // 成交时间
   ENUM_DEAL_TYPE deal_type;       // 交易类型（买/卖）
   double        volume;           // 交易手数
   double        request_price;    // 请求价格
   double        deal_price;       // 成交价格
   double        spread_cost;      // 点差成本
   double        commission;       // 佣金
   double        swap;             // 隔夜利息
   double        slippage_cost;    // 滑点成本
   double        total_cost;       // 单笔总成本
   string        symbol;           // 交易品种
};

//+------------------------------------------------------------------+
//| 交易成本追踪器类                                                 |
//+------------------------------------------------------------------+
class CTransactionCostTracker
{
private:
   SDealCostRecord m_records[];    // 成本记录数组
   int             m_record_count; // 记录数量
   
   double          m_total_spread;     // 总点差成本
   double          m_total_commission; // 总佣金
   double          m_total_swap;       // 总隔夜利息
   double          m_total_slippage;   // 总滑点成本
   double          m_total_cost;       // 总成本
   
   // 订单请求价格映射（用于滑点计算）
   struct SOrderRequestInfo
   {
      ulong   order_ticket;
      double  request_price;
      datetime request_time;
   };
   SOrderRequestInfo m_order_requests[];
   int               m_order_request_count;

public:
   // 构造函数
   CTransactionCostTracker();
   // 析构函数
   ~CTransactionCostTracker();
   
   // 记录订单请求（用于后续滑点计算）
   void RecordOrderRequest(ulong ticket, double price);
   
   // 处理新成交，计算并记录成本
   void ProcessNewDeal(ulong deal_ticket);
   
   // 从历史成交记录批量加载数据
   bool LoadFromHistory(datetime start_time = 0);
   
   // 获取统计数据
   double GetTotalSpread()     const { return m_total_spread; }
   double GetTotalCommission() const { return m_total_commission; }
   double GetTotalSwap()       const { return m_total_swap; }
   double GetTotalSlippage()   const { return m_total_slippage; }
   double GetTotalCost()       const { return m_total_cost; }
   int    GetDealCount()       const { return m_record_count; }
   
   // 获取平均每笔成本
   double GetAvgCostPerDeal() const;
   
   // 获取成本率（成本/利润比）
   double GetCostRatio() const;
   
   // 输出统计摘要到日志
   void PrintSummary() const;
   
   // 导出成本记录到CSV文件
   bool ExportToCSV(string filename) const;

private:
   // 计算点差成本
   double CalculateSpreadCost(const string &symbol, double volume, ENUM_DEAL_TYPE deal_type);
   // 计算滑点成本
   double CalculateSlippageCost(ulong deal_ticket, double deal_price, ENUM_DEAL_TYPE deal_type);
   // 从映射中查找订单请求价格
   double FindRequestPrice(ulong order_ticket);
};

//+------------------------------------------------------------------+
//| 构造函数                                                         |
//+------------------------------------------------------------------+
CTransactionCostTracker::CTransactionCostTracker()
{
   m_record_count = 0;
   m_order_request_count = 0;
   m_total_spread = 0;
   m_total_commission = 0;
   m_total_swap = 0;
   m_total_slippage = 0;
   m_total_cost = 0;
   
   // 数组预留空间
   ArrayResize(m_records, 1000);
   ArrayResize(m_order_requests, 500);
}

//+------------------------------------------------------------------+
//| 析构函数                                                         |
//+------------------------------------------------------------------+
CTransactionCostTracker::~CTransactionCostTracker()
{
   // 无需手动释放，MQL5自动管理内存
}

//+------------------------------------------------------------------+
//| 记录订单请求价格（开仓前调用）                                   |
//+------------------------------------------------------------------+
void CTransactionCostTracker::RecordOrderRequest(ulong ticket, double price)
{
   // 检查是否已满，满了就扩容
   if(m_order_request_count >= ArraySize(m_order_requests))
   {
      ArrayResize(m_order_requests, m_order_request_count + 500);
   }
   
   m_order_requests[m_order_request_count].order_ticket = ticket;
   m_order_requests[m_order_request_count].request_price = price;
   m_order_requests[m_order_request_count].request_time = TimeCurrent();
   m_order_request_count++;
}

//+------------------------------------------------------------------+
//| 处理新成交记录                                                   |
//+------------------------------------------------------------------+
void CTransactionCostTracker::ProcessNewDeal(ulong deal_ticket)
{
   // 选择历史记录
   if(!HistorySelect(0, TimeCurrent()))
   {
      Print("CostTracker: HistorySelect failed, error=", GetLastError());
      return;
   }
   
   // 获取成交记录索引
   int deal_idx = HistoryDealGetTicketIndex(deal_ticket);
   if(deal_idx < 0)
   {
      // 尝试在更宽范围内查找
      if(!HistorySelect(TimeCurrent() - 86400 * 30, TimeCurrent()))
         return;
      deal_idx = HistoryDealGetTicketIndex(deal_ticket);
      if(deal_idx < 0)
         return;
   }
   
   // 获取成交信息
   string   symbol     = HistoryDealGetString(deal_ticket, DEAL_SYMBOL);
   double   volume     = HistoryDealGetDouble(deal_ticket, DEAL_VOLUME);
   double   deal_price = HistoryDealGetDouble(deal_ticket, DEAL_PRICE);
   double   commission = HistoryDealGetDouble(deal_ticket, DEAL_COMMISSION);
   double   swap       = HistoryDealGetDouble(deal_ticket, DEAL_SWAP);
   long     deal_type  = HistoryDealGetInteger(deal_ticket, DEAL_TYPE);
   datetime deal_time  = (datetime)HistoryDealGetInteger(deal_ticket, DEAL_TIME);
   ulong    order_id   = (ulong)HistoryDealGetInteger(deal_ticket, DEAL_ORDER);
   
   // 计算点差成本
   double spread_cost = CalculateSpreadCost(symbol, volume, (ENUM_DEAL_TYPE)deal_type);
   
   // 计算滑点成本
   double slippage_cost = CalculateSlippageCost(deal_ticket, deal_price, (ENUM_DEAL_TYPE)deal_type);
   
   // 计算单笔总成本（注意：佣金、隔夜利息、滑点可能为正或负）
   double total_cost = spread_cost + commission + slippage_cost;
   // 隔夜利息单独统计（可能为负，代表收益）
   
   // 保存记录
   if(m_record_count >= ArraySize(m_records))
   {
      ArrayResize(m_records, m_record_count + 1000);
   }
   
   m_records[m_record_count].deal_ticket   = deal_ticket;
   m_records[m_record_count].deal_time     = deal_time;
   m_records[m_record_count].deal_type     = (ENUM_DEAL_TYPE)deal_type;
   m_records[m_record_count].volume        = volume;
   m_records[m_record_count].request_price = FindRequestPrice(order_id);
   m_records[m_record_count].deal_price    = deal_price;
   m_records[m_record_count].spread_cost   = spread_cost;
   m_records[m_record_count].commission    = commission;
   m_records[m_record_count].swap          = swap;
   m_records[m_record_count].slippage_cost = slippage_cost;
   m_records[m_record_count].total_cost    = total_cost;
   m_records[m_record_count].symbol        = symbol;
   
   // 累加总计
   m_total_spread     += spread_cost;
   m_total_commission += commission;
   m_total_swap       += swap;
   m_total_slippage   += slippage_cost;
   m_total_cost       += total_cost;
   
   m_record_count++;
}

//+------------------------------------------------------------------+
//| 计算点差成本（估算值，基于成交时的点差）                          |
//+------------------------------------------------------------------+
double CTransactionCostTracker::CalculateSpreadCost(const string &symbol, 
                                                    double volume,
                                                    ENUM_DEAL_TYPE deal_type)
{
   // 点差成本 = 点差 × 每点价值 × 手数
   // 注意：这是估算，因为我们无法精确知道成交瞬间的点差
   double spread = SymbolInfoDouble(symbol, SYMBOL_ASK) - SymbolInfoDouble(symbol, SYMBOL_BID);
   double point  = SymbolInfoDouble(symbol, SYMBOL_POINT);
   double tick_value = SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_VALUE);
   double tick_size  = SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_SIZE);
   
   if(tick_size <= 0 || point <= 0) return 0;
   
   // 点差对应的tick数
   double spread_ticks = spread / tick_size;
   
   // 点差成本 = tick数 × 每tick价值 × 手数
   double cost = spread_ticks * tick_value * volume;
   
   return cost;
}

//+------------------------------------------------------------------+
//| 计算滑点成本                                                     |
//+------------------------------------------------------------------+
double CTransactionCostTracker::CalculateSlippageCost(ulong deal_ticket,
                                                      double deal_price,
                                                      ENUM_DEAL_TYPE deal_type)
{
   // 获取对应的订单号
   int deal_idx = HistoryDealGetTicketIndex(deal_ticket);
   if(deal_idx < 0) return 0;
   
   ulong order_ticket = (ulong)HistoryDealGetInteger(deal_idx, DEAL_ORDER);
   double request_price = FindRequestPrice(order_ticket);
   
   if(request_price <= 0) return 0; // 找不到请求价格，无法计算
   
   double slippage_cost = 0;
   string symbol = HistoryDealGetString(deal_idx, DEAL_SYMBOL);
   double volume = HistoryDealGetDouble(deal_idx, DEAL_VOLUME);
   double tick_value = SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_VALUE);
   double tick_size  = SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_SIZE);
   
   if(tick_size <= 0) return 0;
   
   double price_diff = deal_price - request_price;
   double ticks = price_diff / tick_size;
   
   // 买单：成交价高于请求价 = 负滑点（成本增加）
   // 卖单：成交价低于请求价 = 负滑点（成本增加）
   if(deal_type == DEAL_TYPE_BUY)
   {
      slippage_cost = ticks * tick_value * volume;
   }
   else if(deal_type == DEAL_TYPE_SELL)
   {
      slippage_cost = -ticks * tick_value * volume;
   }
   
   return slippage_cost;
}

//+------------------------------------------------------------------+
//| 查找订单请求价格                                                 |
//+------------------------------------------------------------------+
double CTransactionCostTracker::FindRequestPrice(ulong order_ticket)
{
   for(int i = 0; i < m_order_request_count; i++)
   {
      if(m_order_requests[i].order_ticket == order_ticket)
      {
         return m_order_requests[i].request_price;
      }
   }
   return 0; // 未找到
}

//+------------------------------------------------------------------+
//| 获取平均每笔成本                                                 |
//+------------------------------------------------------------------+
double CTransactionCostTracker::GetAvgCostPerDeal() const
{
   if(m_record_count == 0) return 0;
   return m_total_cost / m_record_count;
}

//+------------------------------------------------------------------+
//| 获取成本率                                                       |
//+------------------------------------------------------------------+
double CTransactionCostTracker::GetCostRatio() const
{
   // 成本率 = 总成本 / (总利润 + 总成本)
   // 需要结合账户历史利润计算，这里简化处理
   double total_profit = 0;
   
   // 遍历成交记录计算总利润
   for(int i = 0; i < m_record_count; i++)
   {
      // 这里需要从DEAL_PROFIT获取，简化示例中未统计
      // 实际使用时建议在ProcessNewDeal中累加DEAL_PROFIT
   }
   
   if((m_total_cost + total_profit) == 0) return 0;
   return m_total_cost / MathAbs(m_total_cost + total_profit);
}

//+------------------------------------------------------------------+
//| 打印统计摘要                                                     |
//+------------------------------------------------------------------+
void CTransactionCostTracker::PrintSummary() const
{
   Print("=== 交易成本统计摘要 ===");
   Print("成交笔数: ", m_record_count);
   Print("点差成本: $", DoubleToString(m_total_spread, 2));
   Print("佣金成本: $", DoubleToString(m_total_commission, 2));
   Print("隔夜利息: $", DoubleToString(m_total_swap, 2));
   Print("滑点成本: $", DoubleToString(m_total_slippage, 2));
   Print("总成本:   $", DoubleToString(m_total_cost, 2));
   Print("单笔平均成本: $", DoubleToString(GetAvgCostPerDeal(), 4));
   Print("========================");
}

//+------------------------------------------------------------------+
//| 导出到CSV文件                                                    |
//+------------------------------------------------------------------+
bool CTransactionCostTracker::ExportToCSV(string filename) const
{
   int handle = FileOpen(filename, FILE_CSV | FILE_WRITE | FILE_ANSI, ',');
   if(handle == INVALID_HANDLE)
   {
      Print("CostTracker: 无法打开文件 ", filename, " 错误: ", GetLastError());
      return false;
   }
   
   // 写入表头
   FileWrite(handle, "成交单号,时间,品种,类型,手数,请求价,成交价,点差成本,佣金,隔夜利息,滑点成本,总成本");
   
   // 写入数据
   for(int i = 0; i < m_record_count; i++)
   {
      string type_str = (m_records[i].deal_type == DEAL_TYPE_BUY) ? "买入" : "卖出";
      FileWrite(handle,
                LongToString(m_records[i].deal_ticket), ",",
                TimeToString(m_records[i].deal_time), ",",
                m_records[i].symbol, ",",
                type_str, ",",
                DoubleToString(m_records[i].volume, 2), ",",
                DoubleToString(m_records[i].request_price, 5), ",",
                DoubleToString(m_records[i].deal_price, 5), ",",
                DoubleToString(m_records[i].spread_cost, 4), ",",
                DoubleToString(m_records[i].commission, 4), ",",
                DoubleToString(m_records[i].swap, 4), ",",
                DoubleToString(m_records[i].slippage_cost, 4), ",",
                DoubleToString(m_records[i].total_cost, 4));
   }
   
   FileClose(handle);
   return true;
}
//+------------------------------------------------------------------+