範例沿用均線交叉下單的 MaCrossTrade.mq5（快慢 EMA 交叉進場、ATR 倍數停損停利、固定 0.10 手），程式一行沒改。商品 EURUSD、H1，報價模式「1分鐘OHLC」。先講結論：訓練段的冠軍，在樣本外和鎖定段兩段都賠錢。

1. 為什麼要切三段

• 訓練段：拿來優化、挑參數。
• 樣本外：冠軍參數凍結後第一次考試。
• 鎖定段：最後一關，只考一次。樣本外考完，人總會想回頭調參數；鎖定段完全不碰，留到最後才用，調過的版本也只能在這裡考一次。

MT5 測試器設置頁的前向測試只切一刀（一段優化、一段前向），前向結果就列在優化結果旁邊，看完很容易回頭改參數。三段切法多留一段完全不碰的資料，這是兩者最大的差別。

測試器也沒有自動「滾動」的功能（每隔一段重新優化、往前推）。這篇只做一次切分，嚴格說是單次前推，不是滾動式的 Walk-Forward。

2. 開跑前先把規則寫死

挑參數的方法如果是看完結果才決定的，三段切得再漂亮也沒用。所以開跑前先寫一份登記，存進版本控制，之後不改：

• 網格：快線 5～20、慢線 20～60、停損 1～3 倍 ATR、停利 2～4 倍 ATR，共 180 組，完整算法、優化標準「最大本日餘額」。
• 選冠軍：交易筆數至少 100、獲利因子大於 1 的組合裡，淨利最高的那組。
• 通過條件：樣本外和鎖定段的獲利因子都要大於 1.2、各至少 30 筆，而且樣本外的獲利因子不能低於訓練段的 6 成。

三段的日期這樣切：

訓練段從 2019 年開始，是因為我這家券商 2018 年的歷史資料不夠細。同一隻 EA 拿 2018 年整年來跑，報告只有 258 根 H1 K 線、1032 個報價（每根 4 個），「質量歷史」0%；樣本外兩年則有 12431 根。一年的 H1 只剩兩百多根，幾乎是一天一根，H1 策略用這種資料回測沒有參考價值。

跳過的那一年半，是之前用同一隻 EA、同一組網格優化過的期間。看過的資料不能再當作沒看過，所以鎖定段改用之後的 15 個月。另外，測試器的結束日期是當天 0 點，不含那一天：樣本外實際測到 2023-12-30，鎖定段測到 2026-09-29。

3. 訓練段：180 組選出冠軍

訓練段 180 組裡，快線等於慢線的 9 組一筆都不會交易；賺錢的有 41 組。照登記的規則，冠軍是快線 20、慢線 40、停損 3 倍 ATR、停利 4 倍 ATR：三年 353 筆、淨利 +723.33、獲利因子 1.12。這組剛好也是 180 組裡淨利最高的，合格條件沒有排掉更好的組合。

執行時出了一個小差錯：登記要求冠軍先存進版本控制再考樣本外，結果那次存檔的指令失敗了，樣本外先跑了。冠軍是程式照規則從訓練結果選出來的，選出的時間早於樣本外開跑，參數沒有因此改動；補存之後，後面每一步都先確認存檔成功才往下做。

4. 考試：樣本外與鎖定段

冠軍參數凍結後，各段都從入金 10,000、空倉重新開始，各跑一趟：

兩段考試都賠錢，獲利因子 0.90 和 0.83 都在 1 以下，離 1.2 的門檻很遠：判定不通過。筆數（296、155 筆）和「質量歷史」（99%、100%）都達到登記的門檻。

淨利已經扣掉點差、手續費和隔夜利息。把樣本外的成交表逐筆加起來：手續費 −177.60、隔夜利息 −39.23，扣這兩項之前的成交損益是 −450.60；鎖定段是 −93.00、−10.93、−364.70。點差已經算在成交價裡，拆不出來；但不計手續費和隔夜利息，兩段也一樣賠錢。

樣本外已經不過，照理可以停在這裡；鎖定段還是照登記跑了，判定用的單趟只跑這一次，結果一樣是賠錢。

5. 換個角度看：冠軍其實排在哪

判定寫下之後，才拿其他資料做對照，這些都不影響結論：

• 樣本外整個網格：同樣 180 組在 2022～2023 年只有 8 組賺錢（另有 9 組沒交易），訓練冠軍排第 78 名。訓練段賺錢的 41 組裡，到樣本外還賺錢的剩 6 組；樣本外至少 30 筆的組合，獲利因子最高 1.13，沒有一組過 1.2。
• 樣本外最賺的那組（快線 20、慢線 50、停損 3、停利 3）在訓練段排第 23 名，照登記的規則事前挑不到它。
• 全段一起優化：把 2019 到 2026 年 9 月全部丟進去優化，180 組只有 3 組賺錢，第一名獲利因子也只有 1.02（898 筆、+323.35），就是上面樣本外最賺的那組。訓練冠軍放在全段是 −597.30。
• 換報價模式：冠軍改用「每次報價」重跑兩段，筆數相同，獲利因子 0.90、0.83，跟「1分鐘OHLC」幾乎一樣。這兩種模式都是從 1 分鐘資料模擬報價，真實報價模式沒有測。

全段第一名就是樣本外最賺的那組。全段本來就包含樣本外那兩年，在其中一段特別好的組合，加總起來也容易排在前面。拿全段優化的第一名當成「這個策略最好的設定」，等於用考試答案回頭挑參數。

6. 這個結果能說明什麼

照登記選出的冠軍沒有通過。整個網格看，訓練段賺錢的 41 組到樣本外只剩 6 組還賺錢，也沒有一組達到 1.2 的門檻：這個均線交叉策略在 EURUSD H1 上，這組網格裡沒有參數達到事先定的通過門檻。

結論的範圍只到這裡：只測了一個商品、一個週期、一種切法。不代表均線交叉在其他商品或週期上一定沒用；反過來，就算某組通過了三段，也還要檢查是不是靠一兩筆大單撐起來、換個商品還成不成立，這些檢查本文沒做。

三段驗證最有用的地方，是把「挑參數」和「打分數」分開。只要在動手前把規則寫死、鎖定段只碰一次，不通過的結果至少是可信的，不會被事後的調整蓋過去。

本篇檔案：MaCrossTrade.mq5 放 MQL5\Experts\，在 MetaEditor 打開按 F7。

範例 EA：ChannelStop.mq5，送單、找單、改單、刪單都在這一個檔；參數、手數（每筆賠餘額 1% 倒推）這些在檔案開頭，文中不貼。文中的日誌都是策略測試器的實際輸出（EURUSD H1，2025 年 1 月，每次報價）。

1. 四種掛單，各看哪個價

掛在現價上方的有兩種：Buy Stop 漲上來就買，追突破；Sell Limit 漲上來才賣，等反彈。現價下方也兩種：Sell Stop 跌下去就賣，追跌破；Buy Limit 跌下來才買，等回檔。另有 Buy Stop Limit、Sell Stop Limit（到價後改掛一張限價單），本文不用。

Stop 這類，MT5 繁中介面叫「止損單」；Limit 這類叫「限價單」。為了不跟保護持倉的停損搞混，本文把 Stop 這類叫停止單。

跟市價單一樣，買單看 Ask、賣單看 Bid。MT5 圖表的 K 線是用 Bid 畫的，所以 K 線最高點還沒到掛單價，Buy Stop 就可能已經成交：

15:19:40  order [#193 buy stop 0.57 EURUSD at 1.03119] triggered
15:19:40  買入停止單成交 @1.03119  當時 Bid 1.03118

那根 H1 K 線（1 月 10 日 15:00）最高只到 1.03118，差 1 點沒碰到掛單價；Ask 比 Bid 高一個點差，先到了。換日時點差會放大，差得更多：1 月 14 日 00:02 那張 Buy Stop 掛 1.02469，成交那一刻 Bid 還在掛單價下方 80 點，只是點差撐開就買進了。

價格一口氣跳過掛單價時，停止單用當時的價格成交，會比掛單價差；限價單則成交在掛單價或更好。另寫一隻測試 EA，在現價下方 30 點各掛一張 Buy Limit、Sell Stop；1 月 10 日 15:30:16 的一個 tick 同時越過兩張的價位：Buy Limit 掛 1.03009，成交在 1.03007，好 2 點；Sell Stop 掛 1.03008，成交在 1.03006，差 2 點。每次報價模式的 tick 是從 1 分鐘 K 線模擬的，跳幾點不代表實盤。

掛單存在券商的伺服器上：EA 停了、電腦關了，價格到了照樣成交。

2. 送出掛單：價格、停損停利、到期時間

//=== 2. 送出掛單：價格、停損停利、到期時間 ==========================
bool Done()                           // 伺服器收了這個請求
{
   uint code = g_Trade.ResultRetcode();
   return code == TRADE_RETCODE_DONE || code == TRADE_RETCODE_PLACED;
}

ENUM_ORDER_TYPE_TIME Life(datetime &expiry)
{
   expiry = 0;
   long can = SymbolInfoInteger(_Symbol, SYMBOL_EXPIRATION_MODE);
   if(i_ExpireBars <= 0 || (can & SYMBOL_EXPIRATION_SPECIFIED) == 0)
      return ORDER_TIME_GTC;          // 一直有效，直到成交或刪掉
   expiry = iTime(_Symbol, _Period, 0)          // 這根的開盤時間
            + i_ExpireBars * PeriodSeconds();   // 再往後 N 根
   return ORDER_TIME_SPECIFIED;       // 到 expiry 就失效
}

bool SendStop(ENUM_ORDER_TYPE type, double price, double sl,
              double tp, double lots)
{
   datetime expiry;
   ENUM_ORDER_TYPE_TIME life = Life(expiry);
   bool ok = (type == ORDER_TYPE_BUY_STOP)
      ? g_Trade.BuyStop(lots, price, _Symbol, sl, tp, life, expiry)
      : g_Trade.SellStop(lots, price, _Symbol, sl, tp, life, expiry);
   if(!ok || !Done())
   {
      Print("掛單失敗 ", g_Trade.ResultRetcode(), " ",
            g_Trade.ResultRetcodeDescription());
      return false;
   }
   return true;
}

CTrade 的 BuyStop、SellStop 依序是手數、掛單價、商品、停損、停利、期限種類、到期時間。停損停利跟著掛單走，成交後就是這筆持倉的停損停利。回 true 只代表請求送出去了，Done() 再看回傳碼：10009 是完成，10008 是單子已放上，都算收了。

期限種類常用三種：ORDER_TIME_GTC 一直有效，直到成交或刪掉；ORDER_TIME_DAY 到當天結束；ORDER_TIME_SPECIFIED 到指定的到期時間。

券商收哪幾種，看 SYMBOL_EXPIRATION_MODE。它是幾個旗標加起來的數，都是 SYMBOL_EXPIRATION_ 開頭：GTC 1、DAY 2、SPECIFIED 4、SPECIFIED_DAY 8（到指定那天結束）；實測 Tickmill 的 EURUSD 是 15＝1＋2＋4＋8，四種都收。can & SYMBOL_EXPIRATION_SPECIFIED 的 & 是位元運算，取出 4 那一位，結果 0 就是不收，跟參數 datetime &expiry 的 &（傳參考）是兩回事。查的時候用 SYMBOL_EXPIRATION_*，送單才用 ORDER_TIME_*，兩組數值不同，不能混用。

範例的 i_ExpireBars 預設 2：到期時間設在兩根 K 線後。EA 正常時每根 K 線都會改單或刪掉重掛，到期時間跟著往後推；EA 當掉或斷線，單子最多再掛兩根 K 線就自己消失（前提是券商收指定到期時間；不收的話 Life() 退回 GTC，就沒有這層保護）。EA 不在的這段時間，沒人會在一張成交後刪另一張，兩張都可能成交，所以別掛太久。

掛錯邊（Buy Stop 掛在 Ask 下方）會被拒，回 10015；到期時間在過去或離現在太近，回 10022。下面兩行是另一隻測試 EA 故意送錯的結果：

failed buy stop 0.1 EURUSD at 1.03595 [Invalid price]
failed buy stop 0.1 EURUSD at 1.06600 [Invalid expiration]

在測試器裡實測，到期時間設在 90 秒後被拒，120 秒後才收。

3. 找自己的掛單

//=== 3. 找自己的掛單 ================================================
ulong FindMyOrder(ENUM_ORDER_TYPE type)
{
   for(int i = OrdersTotal() - 1; i >= 0; i--)
   {
      ulong t = OrderGetTicket(i);    // 順便選取這張，下面才讀得到
      if(t == 0)
         continue;
      if(OrderGetString(ORDER_SYMBOL) != _Symbol ||
         OrderGetInteger(ORDER_MAGIC) != i_Magic)
         continue;
      if(OrderGetInteger(ORDER_TYPE) == type)
         return t;
   }
   return 0;
}

bool DeleteMyOrder(ENUM_ORDER_TYPE type, string why)
{
   ulong t = FindMyOrder(type);
   if(t == 0)
      return true;                    // 本來就沒有
   if(g_Trade.OrderDelete(t) && Done())
   {
      Print("刪掉 #", t, "：", why);
      return true;
   }
   Print("刪單失敗 ", g_Trade.ResultRetcode(), " ",
         g_Trade.ResultRetcodeDescription());
   return false;
}

掛單還沒成交就不是持倉，PositionsTotal 找不到，要用 OrdersTotal 和 OrderGetTicket。OrderGetTicket 回傳訂單編號（ticket），同時選取這張單，之後 OrderGetString、OrderGetInteger、OrderGetDouble 讀的都是它。跟找持倉一樣，用商品和魔術碼認出自己的單，再看類型。

刪單是 OrderDelete(ticket)，測試器日誌會印 order canceled。DeleteMyOrder 回傳有沒有刪成功（沒有要刪的也算成功），下一節會用到。

4. 每根新 K 線：改價，或刪掉重掛

//=== 4. 每根新 K 線：改價，或刪掉重掛 ===============================
void PlaceOrMove(ENUM_ORDER_TYPE type, double price, double atr)
{
   bool   isBuy = (type == ORDER_TYPE_BUY_STOP);
   double now   = SymbolInfoDouble(_Symbol,
                                   isBuy ? SYMBOL_ASK : SYMBOL_BID);
   long   stops = SymbolInfoInteger(_Symbol,
                                   SYMBOL_TRADE_STOPS_LEVEL);
   // 停止單要掛在現價外面，而且至少隔 StopsLevel
   if((isBuy ? price - now : now - price) <= stops * _Point)
   {
      DeleteMyOrder(type, "現價已經過了通道線");
      return;
   }
   double dir = isBuy ? 1 : -1;
   double sl  = NormalizeDouble(price - dir * atr * i_SlAtr, _Digits);
   double tp  = NormalizeDouble(price + dir * atr * i_TpAtr, _Digits);
   double lots = CalcLots(MathAbs(price - sl));

   ulong t = FindMyOrder(type);
   if(t > 0 && MathAbs(OrderGetDouble(ORDER_VOLUME_CURRENT) - lots)
               < 1e-8)
   {
      // 手數沒變：改價、停損停利、到期時間
      datetime expiry;
      ENUM_ORDER_TYPE_TIME life = Life(expiry);
      if(!g_Trade.OrderModify(t, price, sl, tp, life, expiry) ||
         !Done())
         Print("改單失敗 ", g_Trade.ResultRetcode(), " ",
               g_Trade.ResultRetcodeDescription());
      return;
   }
   if(!DeleteMyOrder(type, "手數要換"))   // OrderModify 改不了手數
      return;                         // 舊的刪不掉，就別再掛一張
   if(lots > 0)
      SendStop(type, price, sl, tp, lots);
}

void OnTick()
{
   datetime bar = iTime(_Symbol, _Period, 0);
   if(bar == g_LastBar)
      return;
   g_LastBar = bar;
   if(HavePosition())                 // 有倉就不掛，交給停損停利
   {
      DeleteMyOrder(ORDER_TYPE_BUY_STOP, "已經有持倉");   // 平常早就
      DeleteMyOrder(ORDER_TYPE_SELL_STOP, "已經有持倉");  // 刪掉了
      return;
   }

   g_High.Refresh();
   g_Low.Refresh();
   g_Atr.Refresh();
   int    at;                         // MaxValue 順便回傳位置，不用
   double top = g_High.MaxValue(1, i_Channel, at);  // 前 N 根的
   double bot = g_Low.MinValue(1, i_Channel, at);   // 最高、最低
   double atr = g_Atr.Main(1);
   if(top == EMPTY_VALUE || bot == EMPTY_VALUE || atr == EMPTY_VALUE)
   {
      g_LastBar = 0;                  // 資料還沒好，下個 tick 重來
      return;
   }
   PlaceOrMove(ORDER_TYPE_BUY_STOP, top, atr);
   PlaceOrMove(ORDER_TYPE_SELL_STOP, bot, atr);
}

通道線每根 K 線都可能移動；ATR 一變，停損距離就變，照每筆風險 1% 算出來的手數也跟著變。

OrderModify 能改掛單價、停損停利、到期時間，改不了手數：CTrade 的 OrderModify 沒有手數參數。另寫測試 EA，把一張 0.1 手的掛單用 OrderSend 直接送改單請求（TRADE_ACTION_MODIFY）、手數寫 0.20：測試器裡回 10009 成功，價格改了，手數還是 0.1，不報錯。

所以手數沒變就改單，變了就刪掉重掛；舊的刪不掉就先不掛，免得多出一張。這個月改單 124 次、刪掉重掛 318 次。

停止單要掛在現價外面，還要隔商品的 StopsLevel 點（券商規定掛單價離現價至少幾點，Tickmill 是 0）。新 K 線一開盤就已經在通道外，這一邊就不掛，舊單也刪掉，不去追已經跑掉的價。

有持倉就不掛新單，交給停損停利出場。

5. 一張成交，就刪掉另一張

//=== 5. 一張成交，就刪掉另一張 ======================================
void OnTradeTransaction(const MqlTradeTransaction &trans,
                        const MqlTradeRequest &request,
                        const MqlTradeResult &result)
{
   if(trans.type != TRADE_TRANSACTION_DEAL_ADD)
      return;                         // 只看「多了一筆成交」
   ulong deal = trans.deal;
   if(!HistoryDealSelect(deal) ||
      HistoryDealGetInteger(deal, DEAL_MAGIC) != i_Magic ||
      HistoryDealGetString(deal, DEAL_SYMBOL) != _Symbol ||
      HistoryDealGetInteger(deal, DEAL_ENTRY) != DEAL_ENTRY_IN)
      return;                         // 不是這隻 EA 的進場
   bool isBuy = (HistoryDealGetInteger(deal, DEAL_TYPE)
                 == DEAL_TYPE_BUY);
   Print(isBuy ? "買入停止單" : "賣出停止單", "成交 @",
         DoubleToString(HistoryDealGetDouble(deal, DEAL_PRICE),
                        _Digits), "  當時 Bid ", DoubleToString(
         SymbolInfoDouble(_Symbol, SYMBOL_BID), _Digits));
   DeleteMyOrder(isBuy ? ORDER_TYPE_SELL_STOP : ORDER_TYPE_BUY_STOP,
                 "另一邊成交了");
}

MT5 的單子類型裡沒有「一張成交就取消另一張」（OCO）這種，要 EA 自己刪，而且要馬上刪：等到下一根 K 線才刪，價格掉頭碰到通道另一邊，另一張就可能也成交。

OnTradeTransaction 是交易有變化時 MT5 叫的函數。收到 TRADE_TRANSACTION_DEAL_ADD（多了一筆成交），用 HistoryDealSelect 選出這筆成交，確認是這隻 EA 的進場，就刪掉另一邊：

00:05:04  order [#3 sell stop 0.32 EURUSD at 1.03440] triggered
00:05:04  賣出停止單成交 @1.03433  當時 Bid 1.03433
00:05:04  order canceled [#2 buy stop 0.32 EURUSD at 1.04245]
00:05:04  刪掉 #2：另一邊成交了

6. 在測試器跑一個月

測試設定：EURUSD H1，2025.01.02 到 2025.01.31，每次報價，入金 10000，杠杆 1:100。整個月 34 張停止單成交：21 張正好在掛單價，13 張比掛單價差、最多差 10 點，沒有一張更好。

過期的單，測試器要等下一根 K 線開盤才刪。另一隻測試 EA 送一張 00:32 到期的單：測試週期選 H1，01:00 才刪；選 M15，00:45 就刪。「幾分鐘後失效」這種邏輯，測試器驗不準。

週末也一樣：週五 23:00 改單，到期時間是週六 01:00，週一第一個 tick 才刪：

01.10 23:00:00  order modified [#206 buy stop 0.22 EURUSD at 1.03119]
01.10 23:00:00  order modified [#207 sell stop 0.22 EURUSD at 1.02109]
01.13 00:05:00  order expired [#206 buy stop 0.22 EURUSD at 1.03119]
01.13 00:05:00  order expired [#207 sell stop 0.22 EURUSD at 1.02109]

EA 在同一個 tick 重新掛上新的兩張。

餘額 10000 跑到 9088.53：掛單只決定怎麼進場，這個通道突破在這個月是賠的。

本篇檔案：ChannelStop.mq5 放 MQL5\Experts\，在 MetaEditor 打開按 F7。

範例兩個檔：指標 ChannelBreak.mq5、EA ChannelInd.mq5。EA 的下單、停損、移動停損都交給共用框架 EaKit.mqh，自己只負責讀訊號。文中的日誌都是策略測試器的實際輸出。

先把指標掛上圖表

1. ChannelBreak.mq5 放到 MQL5\Indicators\Blog\（Blog 資料夾自己建），在 MetaEditor 打開按 F7。
2. 導航的「指標」底下會多一個 Blog 資料夾，把 ChannelBreak 拖到 EURUSD H1 圖表上，按確定。

1. 檔頭的 #property：畫在哪、畫幾條

//=== 1. 檔頭的 #property：畫在哪、畫幾條 ============================
#property indicator_chart_window      // 畫在主圖（K 線上）
#property indicator_buffers 4         // 緩衝區（存數值的陣列）
#property indicator_plots   4         // 圖上畫幾樣
#property indicator_label1  "上軌"
#property indicator_type1   DRAW_LINE
#property indicator_color1  clrDodgerBlue
#property indicator_label2  "下軌"
#property indicator_type2   DRAW_LINE
#property indicator_color2  clrDodgerBlue
#property indicator_label3  "向上突破"
#property indicator_type3   DRAW_ARROW
#property indicator_color3  clrLime
#property indicator_width3  2
#property indicator_label4  "向下突破"
#property indicator_type4   DRAW_ARROW
#property indicator_color4  clrRed
#property indicator_width4  2

input int i_Channel = 20;             // 通道看幾根 K 線

double g_Upper[];
double g_Lower[];
double g_Buy[];
double g_Sell[];

indicator_chart_window 表示畫在 K 線那個視窗；RSI 那種畫在下方另一個視窗的，改寫 indicator_separate_window。

indicator_buffers 是存數值的陣列有幾個，indicator_plots 是圖上畫幾樣；這裡都是 4：上軌、下軌、向上箭頭、向下箭頭。後面 label、type、color 結尾的數字是第幾樣，從 1 起算。DRAW_LINE 把每根 K 線的值連成線，DRAW_ARROW 在有值的 K 線畫一個符號。

指標的 input 跟 EA 一樣，掛上圖表時可以改。

2. OnInit：把陣列接成緩衝區

//=== 2. OnInit：把陣列接成緩衝區 ====================================
int OnInit()
{
   if(i_Channel < 1)
      return INIT_PARAMETERS_INCORRECT;
   SetIndexBuffer(0, g_Upper, INDICATOR_DATA);
   SetIndexBuffer(1, g_Lower, INDICATOR_DATA);
   SetIndexBuffer(2, g_Buy,   INDICATOR_DATA);
   SetIndexBuffer(3, g_Sell,  INDICATOR_DATA);
   PlotIndexSetInteger(2, PLOT_ARROW, 233);   // Wingdings 向上箭頭
   PlotIndexSetInteger(3, PLOT_ARROW, 234);   // 向下箭頭
   PlotIndexSetInteger(2, PLOT_ARROW_SHIFT, 15);  // 往下挪 15 像素
   PlotIndexSetInteger(3, PLOT_ARROW_SHIFT, -15); // 往上挪
   PlotIndexSetDouble(2, PLOT_EMPTY_VALUE, 0.0);  // 0＝這根沒箭頭
   PlotIndexSetDouble(3, PLOT_EMPTY_VALUE, 0.0);
   for(int k = 0; k < 4; k++)                 // 前 N 根沒得算，不畫
      PlotIndexSetInteger(k, PLOT_DRAW_BEGIN, i_Channel);
   IndicatorSetString(INDICATOR_SHORTNAME,
                      "ChannelBreak(" + (string)i_Channel + ")");
   return INIT_SUCCEEDED;
}

SetIndexBuffer 把全域陣列接到第幾個緩衝區（從 0 起算，比 #property 的編號少 1）。接上之後陣列大小由 MT5 管，K 線多一根陣列就多一格，不用 ArrayResize。

PLOT_ARROW 是 Wingdings 字型的字碼，233 是向上箭頭、234 是向下；PLOT_ARROW_SHIFT 把箭頭往下（正數）或往上（負數）挪幾個像素，免得壓在影線上。

PLOT_EMPTY_VALUE 是「這根不畫」的值。線用預設的 EMPTY_VALUE，箭頭改成 0，原因在第 4 節。PLOT_DRAW_BEGIN 讓前 20 根不畫，那幾根還湊不滿一個通道。

3. OnCalculate：只算還沒算過的 K 線

//=== 3. OnCalculate：只算還沒算過的 K 線 ============================
int OnCalculate(const int rates_total, const int prev_calculated,
                const datetime &time[], const double &open[],
                const double &high[], const double &low[],
                const double &close[], const long &tick_volume[],
                const long &volume[], const int &spread[])
{
   if(rates_total <= i_Channel)
      return 0;                       // K 線不夠，下次從頭再來
   int start = prev_calculated - 1;   // 上次最後一根要重算
   if(prev_calculated == 0)
   {
      for(int i = 0; i < i_Channel; i++)
      {
         g_Upper[i] = EMPTY_VALUE;
         g_Lower[i] = EMPTY_VALUE;
         g_Buy[i]   = 0.0;
         g_Sell[i]  = 0.0;
      }
      start = i_Channel;
   }
   for(int i = start; i < rates_total; i++)   // 索引 0 是最舊的
   {
      // 前面 N 根（不含這根）的最高、最低
      g_Upper[i] = high[ArrayMaximum(high, i - i_Channel, i_Channel)];
      g_Lower[i] = low[ArrayMinimum(low, i - i_Channel, i_Channel)];
      g_Buy[i]   = 0.0;
      g_Sell[i]  = 0.0;
      if(i == i_Channel)
         continue;                    // 前一根沒有通道，不比
      if(close[i - 1] <= g_Upper[i - 1] && close[i] > g_Upper[i])
         g_Buy[i] = low[i];           // 剛收上上軌：箭頭畫在低點下
      if(close[i - 1] >= g_Lower[i - 1] && close[i] < g_Lower[i])
         g_Sell[i] = high[i];
   }
   return rates_total;                // 下次的 prev_calculated
}

每來一個 tick，MT5 就叫一次 OnCalculate，把整段 K 線的時間、開高低收陣列傳進來，rates_total 是現在總共幾根。陣列索引 0 是最舊的那根，rates_total - 1 是最新、還沒收完的那根，跟 EA 裡 Main(1) 從新往舊數正好相反。實測第一次呼叫時 time[0] 是 2024.01.02 00:00，time[rates_total-1] 是 2025.01.03 23:00。

prev_calculated 是上一次 OnCalculate 回傳的值。讓 EA 每個 tick 讀一次指標，指標每次印出這兩個數：

00:00:00  rates_total=6284  prev_calculated=0
00:05:00  rates_total=6285  prev_calculated=6284
00:05:07  rates_total=6285  prev_calculated=6285
00:05:15  rates_total=6285  prev_calculated=6285
01:00:00  rates_total=6286  prev_calculated=6285
02:00:00  rates_total=6287  prev_calculated=6286

第一次是 0，整段 6,284 根全部算；同一根 K 線裡的 tick，prev_calculated 等於 rates_total；換新 K 線時少 1。所以從 prev_calculated - 1 算起，兩種情況都對：同一根只重算最後一根，換根時把剛收完的那根用最終收盤價再算一次，再算新的一根。每次都從頭算也能跑，只是每個 tick 都重算幾千根。

最後一根還沒收完，收盤價一直在變，箭頭可能出現又消失，所以迴圈裡每次重算都先把箭頭清成 0，EA 也只看收完的前一根。K 線不夠時回傳 0，下次 prev_calculated 還是 0，會從頭再來。

4. EA 用 CiCustom 讀自訂指標

//=== 4. EA 用 CiCustom 讀自訂指標 ===================================
#property tester_indicator "Blog\\ChannelBreak.ex5"
#include <Indicators\Custom.mqh>
#include <Indicators\Oscilators.mqh>
#include <OrzBlog\EaKit.mqh>

input int  i_Channel   = 20;          // 通道看幾根 K 線
input int  i_AtrPeriod = 14;          // ATR 期數
input long i_Magic     = 20250803;    // 魔術碼，別跟別隻 EA 撞

CEaKit   g_Kit;
CiCustom g_Chan;
CiATR    g_Atr;

int OnInit()
{
   MqlParam par[2];
   par[0].type          = TYPE_STRING;  // 第 1 個一定是指標路徑
   par[0].string_value  = "Blog\\ChannelBreak";
   par[1].type          = TYPE_INT;     // 之後照指標 input 的順序
   par[1].integer_value = i_Channel;
   if(!g_Chan.NumBuffers(4) ||
      !g_Chan.Create(_Symbol, _Period, IND_CUSTOM, 2, par) ||
      !g_Atr.Create(_Symbol, _Period, i_AtrPeriod))
   {
      Print("指標建立失敗，錯誤碼 ", GetLastError());
      return INIT_FAILED;
   }
   return g_Kit.Init(i_Magic) ? INIT_SUCCEEDED : INIT_FAILED;
}

void OnDeinit(const int reason) { g_Kit.Deinit(); }
void OnTimer()                  { g_Kit.OnTimer(); }

void OnTradeTransaction(const MqlTradeTransaction &trans,
                        const MqlTradeRequest &request,
                        const MqlTradeResult &result)
{
   g_Kit.OnTrade(trans);
}

void OnTick()
{
   if(!g_Kit.Ready())
      return;
   g_Kit.ShowStatus();
   if(!g_Kit.IsNewBar())
      return;

   g_Chan.Refresh();
   g_Atr.Refresh();
   double buy  = g_Chan.GetData(2, 1);  // 緩衝區 2、前一根
   double sell = g_Chan.GetData(3, 1);
   double atr1 = g_Atr.Main(1);
   if(buy == EMPTY_VALUE || sell == EMPTY_VALUE ||   // 讀不到
      atr1 == EMPTY_VALUE)
   {
      Print("資料還沒準備好，錯誤碼 ", GetLastError());
      g_Kit.ForgetBar();
      return;
   }

   int dir = -1;                        // 0＝沒箭頭
   if(buy != 0.0)  dir = POSITION_TYPE_BUY;
   if(sell != 0.0) dir = POSITION_TYPE_SELL;
   g_Kit.OnSignal(dir, atr1);
}

CiCustom 建立時要一個 MqlParam 陣列：第 1 個一定是指標路徑（相對 MQL5\Indicators\，不寫 .ex5），之後照指標 input 的順序給值。NumBuffers(4) 要在 Create 之前叫，告訴它指標有幾個緩衝區。GetData(2, 1) 是第 2 號緩衝區（向上箭頭）的前一根，K 線跟 Main(1) 一樣從新往舊數。

不用類別也可以：iCustom(_Symbol, _Period, "Blog\\ChannelBreak", 20) 拿到 handle，指標的 input 直接接在後面當參數，再用 CopyBuffer 讀。

#property tester_indicator 是給策略測試器看的，告訴它這隻 EA 會用到哪個指標。官方文件說：用 iCustom 而且路徑是寫死的字串，測試器自己找得到；其他寫法（CiCustom 就是）要寫這一行。實測在自己電腦上，拿掉這行也照跑，結果跟有寫一樣，因為指標檔就在本機的 Indicators 資料夾；把指標檔也拿掉，就是下面這種 4802。這行是為測試交給其他電腦跑的情況寫的，照文件寫上就好。

路徑打錯，測試器在 OnInit 就停了，連 EA 自己的錯誤訊息都沒機會印：

custom indicator 'Blog\ChannelBrk' cannot load [4802]
indicator create error in 'ChannelIndBad.mq5' (1,1)
OnInit critical error
tester stopped because OnInit failed

箭頭的空值用 0，是因為 GetData 讀不到資料時回傳 EMPTY_VALUE。「沒箭頭」也用 EMPTY_VALUE 的話，EA 分不出「沒訊號」和「讀不到」。實測把指標改成沒箭頭填 EMPTY_VALUE、EA 不動，跑一天：每個 tick 都當成讀不到，「資料還沒準備好」印了 127,296 次，一筆也沒做。

5. 跟直接在 EA 裡算的版本比

同樣的通道突破，也可以在 EA 裡用 CiHigh、CiLow 直接算，例如 ChannelKit.mq5。兩隻 EA 同一天、同設定跑（EURUSD H1，2025.01.02 到 2025.01.31，每次報價，入金 10000，杠杆 1:100）：都是 19 筆交易、最後餘額 10041.55，428 行的日誌除了指標那一行和測試耗時，逐行相同。

算法搬進指標，結果沒變，多了兩個好處：訊號畫在圖上看得到，別隻 EA 也能讀同一個指標。

本篇檔案：ChannelBreak.mq5 放 MQL5\Indicators\Blog\；ChannelInd.mq5 放 MQL5\Experts\；EaKit.mqh 放 MQL5\Include\OrzBlog\。三個檔都在 MetaEditor 打開按 F7，EA 會用到指標編出來的 ChannelBreak.ex5。

範例 NewBarDemo.mq5 是一隻只印不下單的 EA：自己寫一個判斷「新 K 線」的類別 CNewBar，同一隻 EA 建兩個物件，一個看 H1、一個看 H4，各記各的；再用自訂結構 BarStat 記每個週期觸發幾次，結束時印總結。文中的日誌都是策略測試器的實際輸出。

先把範例跑起來

1. NewBarDemo.mq5 放到 MQL5\Experts\，在 MetaEditor 打開按 F7。
2. 策略測試器 Ctrl+R：EA 選 NewBarDemo，EURUSD，H1，2025.01.06 到 2025.01.11，模式「每次報價」，入金 10000，杠杆 1:100，按「開始」，跑完看「日誌」頁。

1. struct：把幾個值綁成一包

//=== 1. struct：把幾個值綁成一包 ====================================
struct BarStat
{
   int      count;                    // 觸發了幾次
   datetime last;                     // 最後一次是哪根 K 線
};

struct 後面是型態名稱，大括號裡是欄位。這樣只是定義了一個新型態，跟 int、datetime 同一級；要用得宣告這個型態的變數，例如 BarStat g_StatH1 = {0, 0};，大括號依序給每個欄位初值。之後用點號取欄位：g_StatH1.count++、g_StatH1.last，跟 dt.day_of_week 同一個用法。

欄位名稱照 MqlDateTime 的習慣用小寫、不加前綴：這種只裝資料的結構，欄位就是給外面直接讀寫的。

2. class：資料和方法放在一起

//=== 2. class：資料和方法放在一起 ===================================
class CNewBar
{
private:
   string          m_Symbol;          // 商品
   ENUM_TIMEFRAMES m_Period;          // 週期
   datetime        m_LastBar;         // 上次看到的 K 線開盤時間

public:
                   CNewBar(string symbol, ENUM_TIMEFRAMES period);
                  ~CNewBar();
   bool            IsNew();           // 本體寫在類別外面
   datetime        LastBar() { return m_LastBar; }
   string          Name()             // PERIOD_H1 取出 H1
   {
      return m_Symbol + " " + StringSubstr(EnumToString(m_Period), 7);
   }
};

類別也是自訂型態，通常把資料和處理資料的方法放在一起。CNewBar 有三個成員變數：商品、週期、上次看到的 K 線開盤時間，名稱用 m_ 開頭，一看就知道是類別自己的。方法有 IsNew()、LastBar()、Name()，另外兩行是建構子和解構子（第 4 節）。

LastBar()、Name() 的本體直接寫在類別裡；IsNew() 在類別裡只有一行宣告，本體寫在外面（第 3 節）。Name() 裡的 m_Period 是 PERIOD_H1 時，EnumToString 回傳字串 “PERIOD_H1″，StringSubstr 去掉前面 7 個字元，剩 “H1″。

private: 底下的成員只有類別自己的方法能讀寫，public: 底下的類別外面也能用。在類別外面（例如 OnTick 裡）透過物件讀 m_LastBar，編譯報 cannot access to private member（error 211）。要讓外面讀，就開一個 public 方法把值回傳出去，LastBar() 就是：外面讀得到，改不了。

struct 其實也能有方法、也能寫 private:。本篇用得到的差別只有一個：沒寫 private:／public: 的時候，struct 預設 public，class 預設 private。把範例的 struct BarStat 改成 class BarStat、其他不動，編譯先在兩個用 = {0, 0} 給初值的地方報 cannot be initialized with initializer list（error 242），接著每個讀寫 count、last 的地方報 error 211；在大括號裡第一行補上 public:，就又編得過。所以習慣上，只裝資料、給外面直接讀寫的用 struct；有狀態要保護的用 class。

3. 方法寫在類別外面：類別名::

//=== 3. 方法寫在類別外面：類別名:: ==================================
bool CNewBar::IsNew()
{
   datetime t = iTime(m_Symbol, m_Period, 0);   // 這根的開盤時間
   if(t == 0 || t == m_LastBar)                 // 0＝資料還沒到
      return false;
   m_LastBar = t;
   return true;
}

本體寫在類別外面，名字前要加 CNewBar::，意思是「CNewBar 的 IsNew」。有了這個前綴，本體裡才能直接用 m_Symbol、m_LastBar 這些成員，private 的也可以。

iTime 取這根 K 線的開盤時間，跟 m_LastBar 一樣就是同一根；不一樣就是新的一根，記下來、回傳 true。取不到會回傳 0（例如資料還沒載好），當作沒有新 K 線。m_LastBar 的初值是 0（建構子給的，第 4 節），所以 EA 一啟動，當下這根就會算一次。

漏了 CNewBar::，外面那個就變成跟類別無關的普通函數，本體裡找不到 m_LastBar，報 undeclared identifier（error 256）。本體剛好沒用到成員的話，錯誤改成指在類別裡那行宣告：function ‘CNewBar::IsNew’ must have a body（error 111），類別宣告了 IsNew，卻沒有本體。

哪些寫裡面、哪些寫外面，編譯器都接受。一兩行的寫在類別裡，長的寫外面，類別宣告就能一眼看完。

4. 建構子與解構子

//=== 4. 建構子與解構子 ==============================================
CNewBar::CNewBar(string symbol, ENUM_TIMEFRAMES period)
   : m_Symbol(symbol), m_Period(period), m_LastBar(0)
{
   Print("建構 ", Name());
}

CNewBar::~CNewBar()
{
   Print("解構 ", Name());
}

建構子是名字跟類別一樣、不寫回傳型態的方法，物件建立時自動執行一次，負責給成員初值。參數後面冒號接的是初始化列：m_Symbol(symbol) 把參數 symbol 放進 m_Symbol，三個成員都給好了才進大括號，所以大括號裡的 Name() 已經印得出「EURUSD H1」。建構子也能整個寫在類別裡，冒號和初始化列照樣接在參數後面。

解構子是名字前面加 ~ 的那個，物件要消失時自動執行，拿來收尾。這裡兩個都只印一行，看它們什麼時候跑：

建構 EURUSD H1
建構 EURUSD H4
OnInit
EURUSD H1 新 K 線 2025.01.06 00:00  第 1 次
...
OnDeinit
...
解構 EURUSD H4
解構 EURUSD H1

全域物件在 OnInit 之前就建好，OnDeinit 跑完才解構。建構照宣告順序（H1 先），解構順序相反（H4 先）。建構子裡已經印得出 EURUSD，表示這時 _Symbol 已經有值；OnDeinit 裡兩個物件都還在，總結才印得出來。

全域物件的建構、解構只發生在 EA 載入和卸載的時候。換圖表的商品或週期不算卸載：我另外寫了一隻小 EA 掛在圖表上實測（不是測試器），讓它把自己的圖表從 EURUSD H1 換成 GBPUSD H4，結果只多跑了一次 OnDeinit、OnInit，全域物件沒有重建，裡面記的商品還是 EURUSD（官方文件也寫：換商品或週期時，全域變數不重設）。範例的 g_H1、g_H4 也一樣，圖表換了商品，它們看的還是建構時的商品；範例只用來看執行時機，沒處理這種情況。

5. 一個類別，兩個物件

//=== 5. 一個類別，兩個物件 ==========================================
CNewBar g_H1(_Symbol, PERIOD_H1);
CNewBar g_H4(_Symbol, PERIOD_H4);
BarStat g_StatH1 = {0, 0};
BarStat g_StatH4 = {0, 0};

int OnInit()
{
   Print("OnInit");
   return INIT_SUCCEEDED;
}

void OnTick()
{
   if(g_H1.IsNew())
      Count(g_H1, g_StatH1);
   if(g_H4.IsNew())
      Count(g_H4, g_StatH4);
}

void Count(CNewBar &bar, BarStat &stat)   // 物件、結構要加 &
{
   stat.count++;
   stat.last = bar.LastBar();
   Print(bar.Name(), " 新 K 線 ", TimeToString(stat.last),
         "  第 ", stat.count, " 次");
}

void OnDeinit(const int reason)
{
   Print("OnDeinit");
   Summary(g_H1, g_StatH1);
   Summary(g_H4, g_StatH4);
}

void Summary(CNewBar &bar, BarStat &stat)
{
   Print(bar.Name(), " 共 ", stat.count, " 次，最後一根 ",
         TimeToString(stat.last));
}

CNewBar g_H1(_Symbol, PERIOD_H1); 建一個物件，括號裡是傳給建構子的參數。建構子要兩個參數，寫成 CNewBar g_H1; 會報 wrong parameters count, 0 passed, but 2 requires（error 199）。

兩個物件用同一份程式碼，但各有一份自己的成員：g_H1.IsNew() 只動 g_H1 的 m_LastBar，g_H4 的不受影響。OnTick 每個 tick 兩個各問一次。

Count() 的兩個參數都加了 &（傳參考）：傳 g_StatH1 進去，函數裡的 stat 就是 g_StatH1 本身，stat.count++ 改的就是它。物件、結構當參數只能傳參考，沒加 & 編譯報 objects are passed by reference only（error 293）。

觸發的前幾行（只列 EA 印的，左邊是測試器時間）：

2025.01.06 00:05:00   EURUSD H1 新 K 線 2025.01.06 00:00  第 1 次
2025.01.06 00:05:00   EURUSD H4 新 K 線 2025.01.06 00:00  第 1 次
2025.01.06 01:00:00   EURUSD H1 新 K 線 2025.01.06 01:00  第 2 次
2025.01.06 02:00:00   EURUSD H1 新 K 線 2025.01.06 02:00  第 3 次
2025.01.06 03:00:00   EURUSD H1 新 K 線 2025.01.06 03:00  第 4 次
2025.01.06 04:00:00   EURUSD H1 新 K 線 2025.01.06 04:00  第 5 次
2025.01.06 04:00:00   EURUSD H4 新 K 線 2025.01.06 04:00  第 2 次

第一個 tick 在 00:05，印的是那根 K 線的開盤時間 00:00。之後 H1 每一根印一次；H4 只有開盤時間在 0、4、8、12、16、20 點的那幾根，跟 H1 同一個 tick、排在 H1 後面。結束時的總結：

OnDeinit
EURUSD H1 共 120 次，最後一根 2025.01.10 23:00
EURUSD H4 共 30 次，最後一根 2025.01.10 20:00

一週五天，H1 共 120 次，跟日誌裡測試器印的「120 bars generated」一樣；H4 30 次。

本篇檔案：NewBarDemo.mq5 放 MQL5\Experts\，在 MetaEditor 打開按 F7 就能用。

三個範例檔。EaKit.mqh 是共用框架，622 行；MaCrossKit.mq5 是同一個均線交叉，剩 77 行；ChannelKit.mq5 是第二隻策略：通道突破，81 行。兩隻 EA 都在策略測試器實跑，文中的日誌都是實際輸出。

先把範例跑起來

1. EaKit.mqh 放到 MQL5\Include\OrzBlog\（OrzBlog 資料夾自己建）；兩隻 EA 放 MQL5\Experts\，在 MetaEditor 各按一次 F7。
2. 策略測試器 Ctrl+R：EURUSD，H1，2025.01.02 到 2025.01.31，模式「每次報價」，入金 10000，杠杆 1:100；EA 先選 MaCrossKit 跑一次，再換 ChannelKit 跑一次。

1. #include 怎麼找檔

#include <OrzBlog\EaKit.mqh>  // 到 MQL5\Include\ 找
#include "EaKit.mqh"           // 到這個 .mq5 的資料夾找

角括號到 MQL5\Include\ 找，引號到「寫這行 #include 的檔」所在的資料夾找，兩種都可以帶子資料夾。兩邊不互相退讓：引號寫 "OrzBlog\EaKit.mqh"，EA 旁邊沒有就報 not found，不會再去 Include 找；角括號也不會找 EA 旁邊的檔。多隻 EA 共用的放 Include，只給一隻 EA 用的放它旁邊。

編譯時 .mqh 的內容整段貼進來，一起編成 .ex5。所以 .ex5 不需要 .mqh 就能跑——我跑回測的那個終端，Include 底下根本沒有 OrzBlog。反過來，改了 .mqh 之後，用到它的每隻 EA 都要重新按 F7，新的 .ex5 才有改過的內容。

同一個檔被引入兩次很常見：MaCrossKit 引的 Trend.mqh 和 Oscilators.mqh 都各自引了 Indicator.mqh。編譯器只收一次，實測連兩條不同路徑指到同一個檔也一樣，所以 C 語言那套 #ifndef 守衛在 MQL5 不必寫。

2. 共用的參數跟著 .mqh 走

//=== 2. 共用的參數跟著 .mqh 走 ======================================
#include <Trade\Trade.mqh>

input group "共用：風險與出場"
input double i_RiskPct    = 1.0;      // 每筆風險（餘額的 %）
input double i_MaxLots    = 1.0;      // 手數上限
input double i_SlAtr      = 2.0;      // 停損 = ATR x 倍數
input double i_TpAtr      = 3.0;      // 停利倍數，0 不設
input double i_BeAtr      = 1.0;      // 保本門檻倍數，0 不用
input int    i_BeLockPts  = 10;       // 保本時多鎖幾點
input double i_TrailAtr   = 2.0;      // 移動停損倍數，0 不用
input int    i_Retry      = 3;        // 下單最多送幾次
input group "共用：通知"
input bool   i_NotifyPush  = true;    // 推播到手機
input bool   i_NotifyMail  = false;   // 寄電子郵件
input bool   i_NotifyAlert = false;   // 本機跳視窗
input string i_WebhookUrl  = "";      // 空白＝不送 WebRequest
input int    i_StaleMin    = 30;      // 幾分鐘沒報價就警告，0 不用

input 寫在 .mqh 裡也算數，每隻引入它的 EA 輸入頁都會有這些參數；input group 在輸入頁加一行分組標題。順序照原始碼由上往下：#include 寫在 EA 自己的 input 前面，共用的就排前面。測試器日誌開頭列的參數就是這個順序：

共用：風險與出場=
i_RiskPct=1.0
i_MaxLots=1.0
...
共用：通知=
i_NotifyPush=true
...
i_FastPeriod=10
i_SlowPeriod=30
i_MaMethod=1
i_AtrPeriod=14
i_Magic=20250801

兩個限制。名稱會撞：EA 再宣告一次 i_RiskPct，編譯報 variable already defined（error 125）。預設值每隻 EA 都一樣：想讓每隻不同的，就別放進 .mqh。魔術碼就是這種——同一個商品上掛的每隻 EA 必須不同（同一隻掛兩個週期也算兩隻），所以它留在 EA 自己的 input，啟動時再交給框架。MaCrossKit 沿用 MaCrossMonitor 的 20250801，因為它是來取代舊版的，兩隻不會同時掛。

3. 用類別把狀態收起來

//=== 3. 用類別把狀態收起來 ==========================================
class CEaKit
{
private:
   CTrade   m_Trade;
   long     m_Magic;
   datetime m_LastBarTime;
   bool     m_Ready;                  // 自檢過了沒
   string   m_LastBad;                // 上次自檢的結果，變了才印
   string   m_LogName;                // 事件檔檔名（Common\Files）
   datetime m_DayStart;               // 日結從幾點起算
   bool     m_StaleSaid;              // 「報價停了」印過了沒

   bool     Preflight();
   void     AdoptPosition();
   double   CalcLots(double slDist, double &risk);
   bool     EnoughMargin(ENUM_ORDER_TYPE type, double lots,
                         double price);
   bool     SendMarket(bool isBuy, double lots, double sl, double tp);
   bool     OpenPosition(int dir, double atr);
   void     ManagePosition(ulong ticket, int type, double atr);
   double   PositionNet(long pos);
   void     DailySummary(datetime from, datetime to);
   void     CheckStale(datetime now);
   bool     InSession(datetime now, datetime &open);

public:
            CEaKit() : m_Magic(0), m_LastBarTime(0), m_Ready(false),
                       m_LastBad("?"), m_DayStart(0),
                       m_StaleSaid(false) {}
   bool     Init(long magic);         // OnInit 叫
   void     Deinit();                 // OnDeinit 叫
   bool     Ready();                  // 自檢＋接手，過了才 true
   bool     IsNewBar();
   void     ForgetBar() { m_LastBarTime = 0; } // 這根下個 tick 重來
   int      FindMyPosition(ulong &ticket);
   void     ShowStatus();
   void     OnSignal(int dir, double atr);     // 管倉＋照訊號進出
   void     OnTrade(const MqlTradeTransaction &trans);
   void     OnTimer();
   void     Log(string msg);
   void     Notify(string msg);
};

為什麼不直接把函數搬過去？原本的函數讀 g_Trade、g_LastBarTime、i_Magic 這些全域變數。搬進 .mqh 之後，這些名字要由 EA 提供：EA 沒宣告 i_Magic，編譯報 undeclared identifier（error 256），錯誤指在 .mqh 裡；EA 宣告了就過，寫在 #include 後面也過。.mqh 偷偷依賴 EA 裡的名字，只看 .mqh 本身看不出來。

類別把這些狀態收成自己的成員（m_ 開頭），放在 private:，類別外面碰不到；魔術碼由 Init(magic) 傳進來。EA 只宣告一個 CEaKit g_Kit，呼叫 public: 底下那幾個方法。public: 第一行 CEaKit() : m_Magic(0), … 是建構子，物件建立時自動執行，冒號後面是給成員初值。

方法的本體大多寫在類別外面，名字前加 CEaKit::，表示這是 CEaKit 的方法。例如 IsNewBar，原本讀寫全域的 g_LastBarTime，現在是成員 m_LastBarTime：

bool CEaKit::IsNewBar()
{
   datetime t = iTime(_Symbol, _Period, 0);
   if(t == m_LastBarTime)
      return false;
   m_LastBarTime = t;
   return true;
}

OnTick、OnTimer、OnTradeTransaction 這些事件函數留在 EA，再轉給框架。.mqh 裡如果直接寫了 OnTimer()，EA 想寫自己的就會報 function already defined and has body（error 165）；框架的 OnTimer() 是類別的方法，名字一樣也不衝突。

4. 均線交叉：只剩訊號

//=== 4. 均線交叉：只剩訊號 ==========================================
#include <Indicators\Trend.mqh>
#include <Indicators\Oscilators.mqh>
#include <OrzBlog\EaKit.mqh>

input int            i_FastPeriod = 10;       // 快線期數
input int            i_SlowPeriod = 30;       // 慢線期數
input ENUM_MA_METHOD i_MaMethod   = MODE_EMA; // 均線種類
input int            i_AtrPeriod  = 14;       // ATR 期數
input long           i_Magic      = 20250801; // 魔術碼

CEaKit g_Kit;
CiMA   g_Fast;
CiMA   g_Slow;
CiATR  g_Atr;

int OnInit()
{
   if(!g_Fast.Create(_Symbol, _Period, i_FastPeriod, 0,
                     i_MaMethod, PRICE_CLOSE) ||
      !g_Slow.Create(_Symbol, _Period, i_SlowPeriod, 0,
                     i_MaMethod, PRICE_CLOSE) ||
      !g_Atr.Create(_Symbol, _Period, i_AtrPeriod))
   {
      Print("指標建立失敗，錯誤碼 ", GetLastError());
      return INIT_FAILED;
   }
   return g_Kit.Init(i_Magic) ? INIT_SUCCEEDED : INIT_FAILED;
}

void OnDeinit(const int reason) { g_Kit.Deinit(); }
void OnTimer()                  { g_Kit.OnTimer(); }

void OnTradeTransaction(const MqlTradeTransaction &trans,
                        const MqlTradeRequest &request,
                        const MqlTradeResult &result)
{
   g_Kit.OnTrade(trans);
}

void OnTick()
{
   if(!g_Kit.Ready())
      return;
   g_Kit.ShowStatus();
   if(!g_Kit.IsNewBar())
      return;

   g_Fast.Refresh();
   g_Slow.Refresh();
   g_Atr.Refresh();
   double fast1 = g_Fast.Main(1), fast2 = g_Fast.Main(2);
   double slow1 = g_Slow.Main(1), slow2 = g_Slow.Main(2);
   double atr1  = g_Atr.Main(1);
   if(fast2 == EMPTY_VALUE || slow2 == EMPTY_VALUE ||
      atr1  == EMPTY_VALUE)
   {
      Print("指標資料還沒準備好，錯誤碼 ", GetLastError());
      g_Kit.ForgetBar();
      return;
   }

   int dir = -1;                                  // -1 = 沒訊號
   if(fast2 <= slow2 && fast1 > slow1) dir = POSITION_TYPE_BUY;
   if(fast2 >= slow2 && fast1 < slow1) dir = POSITION_TYPE_SELL;
   g_Kit.OnSignal(dir, atr1);
}

OnTick 剩四件事：框架說可以動了沒、在圖上顯示持倉、是不是新 K 線、讀指標算訊號。訊號用 -1 表示沒有，POSITION_TYPE_BUY／POSITION_TYPE_SELL 表示方向，交給 OnSignal：它先管手上的倉（保本、移動停損），同方向不動，反方向先平再開。

抽完要證明行為沒變。同一天用同樣設定各跑一次 MaCrossMonitor 和 MaCrossKit：日誌裡帶時間的 376 行（EA 印的加上測試器自己的成交紀錄）只差事件檔檔名那一行，其餘逐字相同，包括 78 行開倉、保本、移動、平倉；報告的 28 筆成交也一樣，14 筆交易，總淨盈利 416.00。「同一天」要講究：策略測試器用的是券商現在的隔夜利息，隔天重跑，損益可能差幾分錢。

5. 第二隻 EA：通道突破

跟 MaCrossKit 一樣的樣板，用一行註解帶過：

//=== 5. 第二隻 EA：通道突破 =========================================
#include <Indicators\TimeSeries.mqh>
#include <Indicators\Oscilators.mqh>
#include <OrzBlog\EaKit.mqh>

input int  i_Channel   = 20;          // 通道看幾根 K 線
input int  i_AtrPeriod = 14;          // ATR 期數
input long i_Magic     = 20250802;    // 魔術碼，別跟別隻 EA 撞

CEaKit g_Kit;
CiHigh  g_High;
CiLow   g_Low;
CiClose g_Close;
CiATR   g_Atr;

int OnInit()
{
   if(!g_High.Create(_Symbol, _Period) ||
      !g_Low.Create(_Symbol, _Period) ||
      !g_Close.Create(_Symbol, _Period) ||
      !g_Atr.Create(_Symbol, _Period, i_AtrPeriod))
   {
      Print("指標建立失敗，錯誤碼 ", GetLastError());
      return INIT_FAILED;
   }
   return g_Kit.Init(i_Magic) ? INIT_SUCCEEDED : INIT_FAILED;
}

// …OnDeinit、OnTimer、OnTradeTransaction 跟 MaCrossKit.mq5 一樣

void OnTick()
{
   // …Ready、ShowStatus、IsNewBar 跟 MaCrossKit.mq5 一樣

   g_High.Refresh();
   g_Low.Refresh();
   g_Close.Refresh();
   g_Atr.Refresh();
   int    at;                           // MaxValue 順便回傳位置，不用
   double top1   = g_High.MaxValue(2, i_Channel, at); // 前一根之前
   double bot1   = g_Low.MinValue(2, i_Channel, at);  // 的 N 根
   double top2   = g_High.MaxValue(3, i_Channel, at);
   double bot2   = g_Low.MinValue(3, i_Channel, at);
   double close1 = g_Close.GetData(1);
   double close2 = g_Close.GetData(2);
   double atr1   = g_Atr.Main(1);
   if(top2 == EMPTY_VALUE || bot2 == EMPTY_VALUE ||
      close2 == EMPTY_VALUE || atr1 == EMPTY_VALUE)
   {
      Print("資料還沒準備好，錯誤碼 ", GetLastError());
      g_Kit.ForgetBar();
      return;
   }

   int dir = -1;                        // 剛收在通道外才算突破
   if(close2 <= top2 && close1 > top1) dir = POSITION_TYPE_BUY;
   if(close2 >= bot2 && close1 < bot1) dir = POSITION_TYPE_SELL;
   g_Kit.OnSignal(dir, atr1);
}

收盤剛站上前 20 根 K 線（不含剛收的那根）的最高價就做多，剛跌破最低價就做空。CiHigh／CiLow 的 MaxValue／MinValue 從第 2 根起往回找 i_Channel 根，第三個參數回傳找到的位置，這裡用不到。

保本、移動停損、事件檔、出場通知、日結，這隻 EA 一行都沒寫，全在框架裡。魔術碼 20250802，跟均線交叉不同，兩隻掛在同一個商品上才分得清誰的倉。同一段 2025 年 1 月：19 筆交易，總淨盈利 41.55。前三筆：

開空 #2  0.34 手 @1.03169  停損 294 點  風險 99.96
[通知] 出場 #2 停利 0.34 手  損益 147.90
開多 #4  0.35 手 @1.03042  停損 288 點  風險 100.80
[通知] 出場 #4 停利 0.35 手  損益 149.10
開多 #6  0.25 手 @1.04220  停損 401 點  風險 100.25
[通知] 出場 #6 停損 0.25 手  損益 -102.00

本篇檔案：EaKit.mqh 放 MQL5\Include\OrzBlog\；MaCrossKit.mq5、ChannelKit.mq5 放 MQL5\Experts\。在 MetaEditor 打開 EA 按 F7 就能用。