iCustom関数を使えば、MT4のIndicatorsフォルダにあるカスタムインジケーターの値をEA（エキスパートアドバイザー）から自由に取得できます。つまり、チャート上で矢印やラインを表示するインジケーターのシグナルを、そのまま自動売買のロジックに組み込めるのです。

この記事では、iCustom関数の基本的な構文から、実践的なサンプルコードまで、初心者にもわかりやすく解説していきます。

iCustom関数とは？

iCustom関数は、指定したカスタムインジケーターの計算結果（バッファの値）を取得するMQL4の組み込み関数です。

MT4にはiMA（移動平均線）やiRSI（RSI）など、標準インジケーター用の関数が用意されていますが、自作のインジケーターやネットで配布されているインジケーターにはこうした専用関数がありません。そこで活躍するのがiCustom関数です。

iCustom関数を利用すると、Indicatorsフォルダに保存されているあらゆるカスタムインジケーターの値を取得できます。これにより、インジケーターのシグナルをEAのエントリー条件・決済条件として使うことが可能になります。

iCustom関数の構文（シンタックス）

iCustom関数の基本構文は以下の通りです。

double iCustom(
    string symbol,      // 通貨ペア（NULLで現在のチャート）
    int    timeframe,    // 時間足（0で現在の時間足）
    string name,         // カスタムインジケーター名
    ...                  // インジケーターの入力パラメーター（可変）
    int    mode,         // バッファ番号（0〜7）
    int    shift         // 取得するバーの位置（0が最新）
);

各パラメーターの意味を詳しく見ていきましょう。

① symbol（通貨ペア）

値を取得したい通貨ペアを文字列で指定します。現在のチャートの通貨ペアを指定する場合は NULL または _Symbol を使います。別の通貨ペアを指定したい場合は "USDJPY" のように気配値表示ウィンドウの表記通りに記述します。

② timeframe（時間足）

時間軸の種類を指定します。現在のチャートの時間足を使う場合は 0 または PERIOD_CURRENT を指定します。別の時間足を指定する場合は、以下の定数を使います。

③ name（インジケーター名）

カスタムインジケーター名を文字列で指定します。指定するカスタムインジケーターの.ex4ファイルが、MQL4\Indicatorsフォルダまたはそのサブフォルダに保存されている必要があります。

サブディレクトリに配置されている場合は、”サブディレクトリ名\\カスタムインジケータ名”で指定します。

// Indicatorsフォルダ直下の場合
iCustom(NULL, 0, "MyIndicator", ...);

// サブフォルダ「Examples」内の場合
iCustom(NULL, 0, "Examples\\MyIndicator", ...);

④ …（インジケーターの入力パラメーター）

カスタムインジケータの入力パラメータです。渡された入力パラメータの順序は、カスタムインジケータの宣言順に対応する必要があります。ここが一番混乱しやすいポイントです。

パラメーターを省略した場合は、インジケーター側のデフォルト値が使用されます。ただし、途中のパラメーターだけを省略することはできません。変更したいパラメーターより前のパラメーターは、すべてデフォルト値であっても記述する必要があります。

⑤ mode（バッファ番号）

取得したいインジケーターバッファのインデックス番号（0〜7）を指定します。最初のバッファはmode=0です。

例えば、ボリンジャーバンドのようなインジケーターなら：

• バッファ0：ミドルバンド
• バッファ1：アッパーバンド
• バッファ2：ロワーバンド

のように対応します。バッファ番号の確認方法は後述します。

⑥ shift（バーの位置）

カスタムインジケーターの値を取得したいバーの位置を指定します。現在のバーであれば「0」、1本前のバーであれば「1」、2本前のバーであれば「2」と記述します。

EA内では、確定した値を使うため shift=1（1本前の確定バー）を指定するのが一般的です。

バッファ番号の調べ方

iCustom関数を使ううえで最も重要なのが、正しいバッファ番号を知ることです。バッファ番号を間違えると、まったく違う値を取得してしまいます。

方法1：チャート上でマウスカーソルを合わせる

チャート上にセットしたインジケーターのラインや矢印にマウスカーソルをのせて、Value1やValue2などという表示がでれば、iCustomでEA化できます。

方法2：データウィンドウで確認する

MT4の「表示」→「データウィンドウ」を開くと、各インジケーターのバッファ値が一覧で表示されます。上から順に0, 1, 2…のバッファ番号に対応しています。

方法3：ソースコードを確認する

インジケーターの.mq4ファイルがある場合は、SetIndexBuffer() や SetIndexLabel() の記述からバッファ番号を確認できます。

// ソースコードの例
SetIndexBuffer(0, UpperBuffer);  // バッファ0 → アッパーライン
SetIndexBuffer(1, LowerBuffer);  // バッファ1 → ロワーライン
SetIndexBuffer(2, BuySignal);    // バッファ2 → 買いシグナル
SetIndexBuffer(3, SellSignal);   // バッファ3 → 売りシグナル

基本的な使い方：サンプルコード

ここからは、実際のサンプルコードを使って使い方を解説します。

サンプル1：移動平均線カスタムインジケーターの値を取得

まずは、最もシンプルな例です。カスタムインジケーター「MyMA」の値を取得してチャートにコメント表示します。

void OnTick()
{
    // MyMAインジケーターの値を取得（期間20、バッファ0、1本前のバー）
    double ma_value = iCustom(NULL, 0, "MyMA", 20, 0, 1);
    
    // チャートにコメント表示
    Comment("MyMA(20)の値: ", DoubleToString(ma_value, Digits));
}

サンプル2：ボリンジャーバンドカスタムインジケーターの複数バッファを取得

iCustom関数でボリンジャーバンドの値を取得する例です。

void OnTick()
{
    // Bandsインジケーターの各バンドを取得
    int period = 20;
    double deviation = 2.0;
    
    double upper = iCustom(NULL, 0, "Bands", period, 0, deviation, 1, 0);  // アッパーバンド（バッファ1）
    double lower = iCustom(NULL, 0, "Bands", period, 0, deviation, 2, 0);  // ロワーバンド（バッファ2）
    
    Comment("Upper: ", upper, "\nLower: ", lower);
}

サンプル3：矢印シグナルインジケーターでEA化する

これが最も実践的な使い方です。買い矢印・売り矢印を表示するインジケーターのシグナルを使って自動売買するEAのサンプルです。

#property strict

// --- 入力パラメーター ---
input double Lots       = 0.01;    // ロット数
input int    MagicNumber = 12345;  // マジックナンバー
input int    StopLoss    = 50;     // ストップロス（pips）
input int    TakeProfit  = 100;    // テイクプロフィット（pips）

void OnTick()
{
    // --- カスタムインジケーターのシグナル取得 ---
    // 買いシグナル（バッファ0）と売りシグナル（バッファ1）を1本前のバーから取得
    double buySignal  = iCustom(NULL, 0, "MySignalIndicator", 0, 1);
    double sellSignal = iCustom(NULL, 0, "MySignalIndicator", 1, 1);
    
    // --- 現在のポジション数をカウント ---
    int buyCount = 0, sellCount = 0;
    for(int i = OrdersTotal() - 1; i >= 0; i--)
    {
        if(!OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) continue;
        if(OrderSymbol() != Symbol() || OrderMagicNumber() != MagicNumber) continue;
        if(OrderType() == OP_BUY)  buyCount++;
        if(OrderType() == OP_SELL) sellCount++;
    }
    
    // --- 買いエントリー ---
    // シグナルが EMPTY_VALUE でなければ矢印が出現している
    if(buySignal != EMPTY_VALUE && buySignal != 0 && buyCount == 0)
    {
        double sl = Ask - StopLoss * Point * 10;
        double tp = Ask + TakeProfit * Point * 10;
        int ticket = OrderSend(Symbol(), OP_BUY, Lots, Ask, 3, sl, tp,
                               "iCustom Buy", MagicNumber, 0, clrBlue);
        if(ticket < 0)
            Print("買い注文エラー: ", GetLastError());
    }
    
    // --- 売りエントリー ---
    if(sellSignal != EMPTY_VALUE && sellSignal != 0 && sellCount == 0)
    {
        double sl = Bid + StopLoss * Point * 10;
        double tp = Bid - TakeProfit * Point * 10;
        int ticket = OrderSend(Symbol(), OP_SELL, Lots, Bid, 3, sl, tp,
                               "iCustom Sell", MagicNumber, 0, clrRed);
        if(ticket < 0)
            Print("売り注文エラー: ", GetLastError());
    }
}

ポイントは、矢印が表示されていないバーでは EMPTY_VALUE（空の値）が返されるという点です。矢印系のシグナルインジケーターをEA化する場合、この EMPTY_VALUE との比較がエントリー判定の基本パターンになります。

iCustom関数を使う際の注意点

1. .ex4ファイルが必要

iCustom関数が参照するのは、コンパイル済みの.ex4ファイルです。ソースコード（.mq4）だけではなく、必ずコンパイルして.ex4ファイルを生成しておきましょう。

2. バッファレスインジケーターには使えない

オシレーター系のインジケーターの場合はバッファが不可欠なので問題ないのですが、メインチャートに表示される矢印系のインジケーターの場合にはバッファで処理していないことがあります。「バッファでシグナルを処理するようにプログラミングしていないこと」、これがiCustomでインジケーターをEA化できない原因です。バッファレスインジケーターはiCustomではEA化できません。

3. パラメーターの順序と型に注意

入力パラメーターはインジケーターのソースコードで宣言された順番通りに指定する必要があります。順番を間違えたり、型が合わないと正しい値が返りません。

4. パフォーマンスを意識する

iCustom関数は呼び出すたびに計算が実行されるため、ティックごとに何度も呼び出すとパフォーマンスが低下します。新しいバーが確定したタイミングでのみ呼び出し、データをキャッシュすると処理速度を改善できます。

// 新しいバーの判定例
static datetime lastBarTime = 0;
if(Time[0] != lastBarTime)
{
    lastBarTime = Time[0];
    // ここでiCustomを呼び出す
    double signal = iCustom(NULL, 0, "MyIndicator", 0, 1);
}

5. バッファ番号は0〜7の範囲

MT4ではインジケーターバッファのインデックスは0〜7の8個までです。バッファが8個を超えるインジケーターの場合、すべての値をiCustomで取得できるとは限りません。

まとめ

iCustom関数は、カスタムインジケーターのシグナルをEAに組み込むための必須関数です。この記事のポイントをまとめます。

• iCustom関数を使えば、Indicatorsフォルダにあるカスタムインジケーターの値をEAから取得できる
• パラメーターは「通貨ペア → 時間足 → インジケーター名 → 入力パラメーター → バッファ番号 → バー位置」の順に指定する
• バッファ番号の確認は、データウィンドウやソースコードから行う
• 矢印シグナル系のインジケーターは EMPTY_VALUE との比較でシグナル判定する
• バッファレスインジケーター（バッファを使わずオブジェクトで描画するもの）には使えない
• パフォーマンスのため、新しいバー確定時にのみ呼び出す工夫をすると良い

まずは簡単なインジケーターから試して、iCustom関数の使い方に慣れていきましょう。シグナルインジケーターをEA化できるようになれば、自動売買の幅が大きく広がりますよ！

投稿 【MQL4】iCustom関数の使い方を徹底解説！カスタムインジケーターをEAから呼び出す方法とサンプルコード は 自動売買を作ろう！ に最初に表示されました。

MQL4ではiWPR関数を使うことで、このウィリアムズ%Rの値を簡単に取得できます。この記事では、iWPR関数の基本的な使い方から、実践的なEA（自動売買）への応用まで、段階的にわかりやすく解説していきます。

ウィリアムズ%Rとは？

ウィリアムズ%Rは、一定期間における最高値と最安値の範囲のなかで、現在の終値がどの位置にあるかをパーセンテージで示す指標です。

計算式

ウィリアムズ%Rの計算式は以下のとおりです。

// ウィリアムズ%Rの計算式（概念）
// %R = (期間内の最高値 - 現在の終値) / (期間内の最高値 - 期間内の最安値) × (-100)

この計算により、値は常に0 ～ -100の範囲で推移します。ここが他のオシレーターと少し違うポイントで、値がマイナスの範囲で動くことを覚えておきましょう。

値の見方

• 0 に近い（-20より上）：買われすぎゾーン → 売りシグナルの候補
• -100 に近い（-80より下）：売られすぎゾーン → 買いシグナルの候補
• -50 付近：中立的な状態

ストキャスティクスと非常に似た性質を持っていますが、ウィリアムズ%Rはスケールが反転している点が特徴です。ストキャスティクスでは値が高いほど買われすぎですが、ウィリアムズ%Rでは値が0に近いほど買われすぎとなります。

iWPR関数の構文

MQL4でウィリアムズ%Rの値を取得するには、iWPR関数を使います。構文は以下のとおりです。

double iWPR(
    string symbol,      // 通貨ペア名
    int    timeframe,   // 時間足
    int    period,      // 計算期間
    int    shift        // シフト（何本前のバーか）
);

引数の詳細

戻り値はdouble型で、0 ～ -100 の範囲の値が返されます。

基本的な使い方

まずは、iWPR関数で値を取得してログに出力するシンプルな例を見てみましょう。

void OnTick()
{
    // 現在のチャート、現在の時間足、期間14、1本前の確定バーのウィリアムズ%Rを取得
    double wpr = iWPR(NULL, 0, 14, 1);

    // エキスパートログに出力
    Print("Williams %%R (1本前) = ", DoubleToString(wpr, 2));

    // 買われすぎ・売られすぎの判定
    if(wpr > -20)
    {
        Print("→ 買われすぎゾーン");
    }
    else if(wpr < -80)
    {
        Print("→ 売られすぎゾーン");
    }
    else
    {
        Print("→ 中立ゾーン");
    }
}

ここでshift に 1 を指定している点がポイントです。shift=0 だと現在まだ形成中のバーの値を取得してしまい、リアルタイムで値が変動します。EA開発では、確定したバー（shift=1）の値を使うのが基本です。

サンプル①：買われすぎ・売られすぎの状態をチャートに表示する

次に、ウィリアムズ%Rの状態をチャートのコメントとしてリアルタイム表示するコードを作ってみましょう。

// ウィリアムズ%Rの状態表示スクリプト
extern int WPR_Period = 14;          // 計算期間
extern double OverBought = -20.0;    // 買われすぎライン
extern double OverSold   = -80.0;    // 売られすぎライン

void OnTick()
{
    double wprCurrent = iWPR(NULL, 0, WPR_Period, 0);
    double wprPrev    = iWPR(NULL, 0, WPR_Period, 1);

    string status = "";

    if(wprPrev > OverBought)
        status = "★ 買われすぎゾーン（売りに注目）";
    else if(wprPrev < OverSold)
        status = "★ 売られすぎゾーン（買いに注目）";
    else
        status = "― 中立ゾーン";

    Comment(
        "===== Williams %R Monitor =====\n",
        "期間: ", WPR_Period, "\n",
        "現在値 (形成中): ", DoubleToString(wprCurrent, 2), "\n",
        "確定値 (1本前) : ", DoubleToString(wprPrev, 2), "\n",
        "状態: ", status, "\n",
        "================================"
    );
}

このコードをEAとしてチャートにセットすると、左上にウィリアムズ%Rの値と状態がリアルタイムで表示されます。動きを観察しながら指標の特性を学ぶのに最適です。

サンプル②：ゾーン脱出型シグナルのシンプルEA

ウィリアムズ%Rを使ったEAを作る際、単純に「-80以下で買い」とするとダマシが多くなります。そこで、ゾーン脱出型の考え方を取り入れます。

ゾーン脱出型とは、以下のようなロジックです。

• 買いシグナル：売られすぎゾーン（-80以下）に入った後、-80を上回って脱出したとき
• 売りシグナル：買われすぎゾーン（-20以上）に入った後、-20を下回って脱出したとき

これにより、ゾーン内に張り付いたまま反転しないケースのダマシを軽減できます。

// ゾーン脱出型 ウィリアムズ%R EA
extern int    WPR_Period  = 14;
extern double LotSize     = 0.01;
extern double OverBought  = -20.0;
extern double OverSold    = -80.0;
extern int    StopLoss    = 100;     // ストップロス（pips）
extern int    TakeProfit  = 200;     // テイクプロフィット（pips）
extern int    MagicNumber = 12345;

void OnTick()
{
    // 新しいバーが確定したときだけ処理する
    static datetime lastBarTime = 0;
    if(Time[0] == lastBarTime) return;
    lastBarTime = Time[0];

    // 確定バーと、その1つ前のバーのウィリアムズ%Rを取得
    double wpr1 = iWPR(NULL, 0, WPR_Period, 1);  // 直近の確定バー
    double wpr2 = iWPR(NULL, 0, WPR_Period, 2);  // その1つ前

    // 既存ポジションの確認
    int posCount = 0;
    for(int i = OrdersTotal() - 1; i >= 0; i--)
    {
        if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
        {
            if(OrderSymbol() == Symbol() && OrderMagicNumber() == MagicNumber)
                posCount++;
        }
    }

    // ポジションがない場合のみエントリー判定
    if(posCount > 0) return;

    double sl, tp;

    // 買いシグナル：売られすぎゾーンから脱出
    if(wpr2 < OverSold && wpr1 >= OverSold)
    {
        sl = Ask - StopLoss * Point * 10;
        tp = Ask + TakeProfit * Point * 10;
        int ticket = OrderSend(Symbol(), OP_BUY, LotSize, Ask, 3, sl, tp,
                               "WPR Buy Signal", MagicNumber, 0, clrBlue);
        if(ticket > 0)
            Print("買いエントリー: WPR=", DoubleToString(wpr1, 2));
        else
            Print("買い注文エラー: ", GetLastError());
    }

    // 売りシグナル：買われすぎゾーンから脱出
    if(wpr2 > OverBought && wpr1 <= OverBought)
    {
        sl = Bid + StopLoss * Point * 10;
        tp = Bid - TakeProfit * Point * 10;
        int ticket = OrderSend(Symbol(), OP_SELL, LotSize, Bid, 3, sl, tp,
                               "WPR Sell Signal", MagicNumber, 0, clrRed);
        if(ticket > 0)
            Print("売りエントリー: WPR=", DoubleToString(wpr1, 2));
        else
            Print("売り注文エラー: ", GetLastError());
    }
}

このEAのポイントは以下のとおりです。

• 新しいバー確定時のみ判定：static変数でバーの時刻を管理し、同じバーで何度も判定しない
• ゾーン脱出の判定：2本前がゾーン内、1本前がゾーン外になったことで「脱出」を検知
• ポジション制限：同時に1ポジションのみ持つようにしている

サンプル③：移動平均線との組み合わせ（トレンドフィルター付きEA）

オシレーター系指標の弱点は、強いトレンドが発生している局面では買われすぎ・売られすぎの状態が長く続き、シグナルが機能しにくいことです。

これを改善するために、移動平均線によるトレンドフィルターを追加したEAを作ってみましょう。

// トレンドフィルター付き ウィリアムズ%R EA
extern int    WPR_Period  = 14;
extern int    MA_Period   = 50;      // 移動平均線の期間
extern int    MA_Method   = MODE_SMA; // 移動平均の種類
extern double LotSize     = 0.01;
extern double OverBought  = -20.0;
extern double OverSold    = -80.0;
extern int    StopLoss    = 100;
extern int    TakeProfit  = 200;
extern int    MagicNumber = 12346;

void OnTick()
{
    // 新しいバー確定時のみ処理
    static datetime lastBarTime = 0;
    if(Time[0] == lastBarTime) return;
    lastBarTime = Time[0];

    // ウィリアムズ%Rの値を取得
    double wpr1 = iWPR(NULL, 0, WPR_Period, 1);
    double wpr2 = iWPR(NULL, 0, WPR_Period, 2);

    // 移動平均線の値を取得
    double ma1 = iMA(NULL, 0, MA_Period, 0, MA_Method, PRICE_CLOSE, 1);

    // 現在の価格と移動平均線の位置関係でトレンドを判定
    double closePrice = Close[1];
    bool isUpTrend   = (closePrice > ma1);  // 上昇トレンド
    bool isDownTrend = (closePrice < ma1);  // 下降トレンド

    // 既存ポジションの確認
    int posCount = 0;
    for(int i = OrdersTotal() - 1; i >= 0; i--)
    {
        if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
        {
            if(OrderSymbol() == Symbol() && OrderMagicNumber() == MagicNumber)
                posCount++;
        }
    }

    if(posCount > 0) return;

    double sl, tp;

    // 買いシグナル：上昇トレンド中 + 売られすぎゾーンから脱出
    if(isUpTrend && wpr2 < OverSold && wpr1 >= OverSold)
    {
        sl = Ask - StopLoss * Point * 10;
        tp = Ask + TakeProfit * Point * 10;
        int ticket = OrderSend(Symbol(), OP_BUY, LotSize, Ask, 3, sl, tp,
                               "WPR+MA Buy", MagicNumber, 0, clrBlue);
        if(ticket > 0)
            Print("買いエントリー（トレンドフィルター付き）: WPR=",
                  DoubleToString(wpr1, 2), " MA=", DoubleToString(ma1, 5));
    }

    // 売りシグナル：下降トレンド中 + 買われすぎゾーンから脱出
    if(isDownTrend && wpr2 > OverBought && wpr1 <= OverBought)
    {
        sl = Bid + StopLoss * Point * 10;
        tp = Bid - TakeProfit * Point * 10;
        int ticket = OrderSend(Symbol(), OP_SELL, LotSize, Bid, 3, sl, tp,
                               "WPR+MA Sell", MagicNumber, 0, clrRed);
        if(ticket > 0)
            Print("売りエントリー（トレンドフィルター付き）: WPR=",
                  DoubleToString(wpr1, 2), " MA=", DoubleToString(ma1, 5));
    }
}

このEAでは、以下のフィルタリングを行っています。

• 買いエントリー：価格が移動平均線より上（上昇トレンド）のときだけ、売られすぎからの脱出シグナルを採用
• 売りエントリー：価格が移動平均線より下（下降トレンド）のときだけ、買われすぎからの脱出シグナルを採用

こうすることで、トレンド方向と逆行するエントリーを防ぎ、勝率の向上が期待できます。

iWPR関数を使う際の注意点

1. 値の範囲はマイナスである

ウィリアムズ%Rの値は0 ～ -100です。RSIのように0～100ではないので、条件式を書くときに符号を間違えないよう注意してください。例えば「-80以下」は wpr < -80 と書きます。

2. トレーディングスタイルに合わせた期間設定

ウィリアムズ%Rの計算期間は、トレーディングスタイルに合わせて調整するのがおすすめです。

3. 強いトレンド相場には注意

オシレーター系指標全般に言えることですが、強い上昇トレンドや下降トレンドでは、ウィリアムズ%Rが買われすぎ・売られすぎゾーンに張り付いたまま動かないことがあります。このような場合、逆張りシグナルが機能しません。サンプル③のようにトレンドフィルターと組み合わせることを強くおすすめします。

4. 確定バーの値を使う

EA開発では、形成中のバー（shift=0）ではなく、確定したバー（shift=1以上）の値を使うのが鉄則です。形成中のバーの値はティックごとに変動するため、シグナルがチラつく原因になります。

まとめ

この記事では、MQL4のiWPR関数を使ってウィリアムズ%Rの値を取得し、EA開発に活用する方法を解説しました。最後にポイントをおさらいしましょう。

• iWPR関数は4つの引数（symbol, timeframe, period, shift）を指定してウィリアムズ%Rの値を取得する
• 値の範囲は0 ～ -100で、-20以上が買われすぎ、-80以下が売られすぎ
• ゾーン脱出型のシグナルにすることで、単純なゾーン判定よりダマシを軽減できる
• 移動平均線などのトレンドフィルターと組み合わせることで、さらに精度を高められる
• EA開発では必ず確定バー（shift=1）の値を使うこと

ウィリアムズ%Rはシンプルな指標ですが、正しく使えばエントリーポイントの精度を上げる強力な武器になります。まずはサンプルコードをストラテジーテスターで動かして、動作を確認するところから始めてみてください！

投稿 【MQL4】iWPR関数の使い方を徹底解説！ウィリアムズ%Rでエントリーシグナルを作ろう は 自動売買を作ろう！ に最初に表示されました。

MQL4には、モメンタムの値を簡単に取得できるiMomentum関数が用意されています。この記事では、iMomentum関数の基本的な使い方から、実際にコピペで動くEAサンプルまで、初心者の方にもわかりやすく徹底解説します。

モメンタムとは？相場の「勢い」を測る指標

モメンタム（Momentum）は、現在の価格と過去の価格の差を見ることで、相場の勢い（速度）を測るテクニカル指標です。MetaTraderのモメンタムは、差ではなく比率（パーセンテージ）で表現されます。

計算式

MetaTraderにおけるモメンタムの計算式は以下のとおりです。

Momentum = (現在の終値 ÷ N期間前の終値) × 100

たとえば期間を14に設定した場合、現在の終値と14本前の終値を比較します。

100ラインの見方

モメンタムの基準値は100です。以下のように判断します。

• 100より上：現在の価格がN期間前より高い → 上昇の勢いがある
• 100より下：現在の価格がN期間前より低い → 下降の勢いがある
• 100ちょうど：N期間前と同じ価格 → 勢いがない

つまり、モメンタムが100ラインを上抜けたら「上昇の勢いが出てきた」、下抜けたら「下降の勢いが出てきた」と判断できるわけです。

iMomentum関数の構文と引数

MQL4でモメンタムの値を取得するには、iMomentum関数を使います。構文は以下のとおりです。

double iMomentum(
   string       symbol,          // 通貨ペア名
   int          timeframe,       // 時間軸
   int          mom_period,      // モメンタムの期間
   int          applied_price,   // 適用価格
   int          shift            // シフト（何本前のバーか）
);

それぞれの引数を詳しく見ていきましょう。

第1引数：symbol（通貨ペア名）

モメンタムを計算する通貨ペアを文字列で指定します。現在のチャートの通貨ペアを使う場合は、NULL または Symbol() を指定します。

第2引数：timeframe（時間軸）

どの時間軸のデータを使うかを指定します。現在のチャートの時間軸を使う場合は 0 または PERIOD_CURRENT を指定します。主な定数は以下のとおりです。

• PERIOD_M1：1分足
• PERIOD_M5：5分足
• PERIOD_M15：15分足
• PERIOD_M30：30分足
• PERIOD_H1：1時間足
• PERIOD_H4：4時間足
• PERIOD_D1：日足
• PERIOD_W1：週足

第3引数：mom_period（期間）

モメンタムの計算期間です。一般的には14がよく使われます。値を小さくすると敏感に反応し、大きくすると滑らかになります。

第4引数：applied_price（適用価格）

計算に使う価格の種類を指定します。通常は終値（PRICE_CLOSE）を使います。

• PRICE_CLOSE（0）：終値
• PRICE_OPEN（1）：始値
• PRICE_HIGH（2）：高値
• PRICE_LOW（3）：安値
• PRICE_MEDIAN（4）：中央値（(高値+安値)÷2）
• PRICE_TYPICAL（5）：典型価格（(高値+安値+終値)÷3）
• PRICE_WEIGHTED（6）：加重終値（(高値+安値+終値+終値)÷4）

第5引数：shift（シフト）

何本前のバーの値を取得するかを指定します。0で現在のバー、1で1本前のバーです。確定した値を使いたい場合は1以上を指定するのが基本です。

基本的な使い方 ― 値を取得してログに出力する

まずは最もシンプルな例として、モメンタムの値を取得してエキスパートログに出力するコードを見てみましょう。

void OnTick()
{
   // 現在のバーのモメンタム値を取得（期間14、終値ベース）
   double mom_current = iMomentum(NULL, 0, 14, PRICE_CLOSE, 0);

   // 1本前のバーのモメンタム値を取得
   double mom_prev = iMomentum(NULL, 0, 14, PRICE_CLOSE, 1);

   // ログに出力
   Print("現在のモメンタム: ", mom_current, " | 1本前: ", mom_prev);

   // 100ラインとの比較
   if(mom_current > 100.0)
   {
      Print("上昇の勢いあり");
   }
   else if(mom_current < 100.0)
   {
      Print("下降の勢いあり");
   }
   else
   {
      Print("勢いなし（ニュートラル）");
   }
}

このコードをEAとしてコンパイルしてチャートにセットすれば、ティックごとにモメンタムの値がログに表示されます。まずはこの基本形を理解しておきましょう。

実践サンプル①：100ラインクロスでエントリーするEA

ここからが本番です。モメンタムが100ラインを上抜けたら買い、下抜けたら売りという、シンプルなEAを作ってみましょう。

//+------------------------------------------------------------------+
//| Momentum Cross EA                                                 |
//+------------------------------------------------------------------+
#property strict

// 入力パラメータ
input int    MomPeriod   = 14;       // モメンタム期間
input double LotSize     = 0.01;     // ロットサイズ
input int    Slippage    = 3;        // スリッページ
input int    StopLoss    = 100;      // ストップロス（ポイント）
input int    TakeProfit  = 200;      // テイクプロフィット（ポイント）
input int    MagicNumber = 12345;    // マジックナンバー

//+------------------------------------------------------------------+
//| Expert tick function                                              |
//+------------------------------------------------------------------+
void OnTick()
{
   // 新しいバーが確定したときだけ処理する
   static datetime lastBarTime = 0;
   if(Time[0] == lastBarTime) return;
   lastBarTime = Time[0];

   // モメンタム値を取得（確定バーを使うためshift=1と2）
   double mom1 = iMomentum(NULL, 0, MomPeriod, PRICE_CLOSE, 1);
   double mom2 = iMomentum(NULL, 0, MomPeriod, PRICE_CLOSE, 2);

   // 現在のポジション数を確認
   int buyCount  = 0;
   int sellCount = 0;
   for(int i = OrdersTotal() - 1; i >= 0; i--)
   {
      if(!OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) continue;
      if(OrderSymbol() != Symbol()) continue;
      if(OrderMagicNumber() != MagicNumber) continue;

      if(OrderType() == OP_BUY)  buyCount++;
      if(OrderType() == OP_SELL) sellCount++;
   }

   // SLとTPの価格を計算するための変数
   double sl = 0, tp = 0;

   // 買いシグナル：モメンタムが100を下から上にクロス
   if(mom2 <= 100.0 && mom1 > 100.0)
   {
      // 売りポジションがあれば決済
      ClosePositions(OP_SELL);

      // 買いポジションがなければエントリー
      if(buyCount == 0)
      {
         sl = (StopLoss  > 0) ? Ask - StopLoss  * Point : 0;
         tp = (TakeProfit > 0) ? Ask + TakeProfit * Point : 0;
         int ticket = OrderSend(Symbol(), OP_BUY, LotSize, Ask, Slippage, sl, tp, "Mom Buy", MagicNumber, 0, clrBlue);
         if(ticket < 0)
            Print("Buy OrderSend error: ", GetLastError());
      }
   }

   // 売りシグナル：モメンタムが100を上から下にクロス
   if(mom2 >= 100.0 && mom1 < 100.0)
   {
      // 買いポジションがあれば決済
      ClosePositions(OP_BUY);

      // 売りポジションがなければエントリー
      if(sellCount == 0)
      {
         sl = (StopLoss  > 0) ? Bid + StopLoss  * Point : 0;
         tp = (TakeProfit > 0) ? Bid - TakeProfit * Point : 0;
         int ticket = OrderSend(Symbol(), OP_SELL, LotSize, Bid, Slippage, sl, tp, "Mom Sell", MagicNumber, 0, clrRed);
         if(ticket < 0)
            Print("Sell OrderSend error: ", GetLastError());
      }
   }
}

//+------------------------------------------------------------------+
//| 指定タイプのポジションを全決済する関数                            |
//+------------------------------------------------------------------+
void ClosePositions(int type)
{
   for(int i = OrdersTotal() - 1; i >= 0; i--)
   {
      if(!OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) continue;
      if(OrderSymbol() != Symbol()) continue;
      if(OrderMagicNumber() != MagicNumber) continue;
      if(OrderType() != type) continue;

      double closePrice = (type == OP_BUY) ? Bid : Ask;
      if(!OrderClose(OrderTicket(), OrderLots(), closePrice, Slippage, clrWhite))
         Print("OrderClose error: ", GetLastError());
   }
}

コードのポイント解説

• 新しいバー判定：Time[0]を使って、バーが確定したタイミングだけ処理を実行します。これにより無駄な注文の重複を防ぎます。
• shift=1と2を使用：確定済みのバーを使ってクロス判定を行います。shift=0は未確定バーなので、シグナルがチラつく原因になります。
• マジックナンバー：このEAのポジションだけを管理するための識別番号です。他のEAとの干渉を防ぎます。
• 決済処理：反対シグナルが出たら既存ポジションを決済してからエントリーする、ドテン売買のロジックです。

実践サンプル②：移動平均線と組み合わせたフィルター関数

モメンタム単体だとダマシが多くなりがちです。そこで、移動平均線（MA）をトレンドフィルターとして組み合わせる方法を紹介します。

//+------------------------------------------------------------------+
//| モメンタム＋移動平均線のシグナル判定関数                          |
//+------------------------------------------------------------------+
int GetFilteredSignal(int momPeriod, int maPeriod)
{
   // モメンタム値（確定バー）
   double mom1 = iMomentum(NULL, 0, momPeriod, PRICE_CLOSE, 1);
   double mom2 = iMomentum(NULL, 0, momPeriod, PRICE_CLOSE, 2);

   // 移動平均線の値（確定バー）
   double ma = iMA(NULL, 0, maPeriod, 0, MODE_SMA, PRICE_CLOSE, 1);

   // 現在の終値（確定バー）
   double closePrice = Close[1];

   // 買いシグナル：MA より上 かつ モメンタム100上抜け
   if(closePrice > ma && mom2 <= 100.0 && mom1 > 100.0)
   {
      return 1;  // 買い
   }

   // 売りシグナル：MA より下 かつ モメンタム100下抜け
   if(closePrice < ma && mom2 >= 100.0 && mom1 < 100.0)
   {
      return -1;  // 売り
   }

   return 0;  // シグナルなし
}

この関数の使い方はシンプルです。OnTick内で以下のように呼び出します。

void OnTick()
{
   int signal = GetFilteredSignal(14, 50);

   if(signal == 1)
   {
      // 買い処理
      Print("フィルター通過：買いシグナル発生！");
   }
   else if(signal == -1)
   {
      // 売り処理
      Print("フィルター通過：売りシグナル発生！");
   }
}

ポイントは、価格がMAより上のときだけ買いシグナルを採用し、MAより下のときだけ売りシグナルを採用するという点です。これにより、トレンドに逆らったエントリーを減らすことができます。

iMomentum関数を使う際の注意点

1. shift値は1以上を使おう

shift=0は現在形成中のバーの値です。ティックごとに値が変わるため、シグナル判定には確定済みのshift=1以降を使うのが鉄則です。shift=0は参考表示用として使いましょう。

2. マルチタイムフレーム使用時の注意

第2引数で現在のチャートと異なる時間軸を指定すると、マルチタイムフレーム分析ができます。ただし、上位足のデータが読み込まれていない場合は正しい値が返りません。必要に応じて事前にチャートを開くか、iMomentumの戻り値が0でないかチェックしましょう。

// 日足のモメンタムを取得
double momDaily = iMomentum(NULL, PERIOD_D1, 14, PRICE_CLOSE, 1);
if(momDaily == 0)
{
   Print("日足データが取得できません");
   return;
}

3. ブローカーによる桁数の違いに注意

StopLossやTakeProfitをポイント単位で指定する場合、3桁/5桁ブローカーでは値の調整が必要です。モメンタム自体の値は比率（パーセンテージ）なので桁数の影響は受けませんが、EA全体のロジックでは注意しましょう。

まとめ

今回は、MQL4のiMomentum関数について基礎から実践まで解説しました。最後に要点を整理しておきます。

• モメンタムは相場の勢いを数値化する指標で、基準値は100
• iMomentum関数は5つの引数（symbol, timeframe, period, applied_price, shift）で値を取得できる
• シグナル判定には確定バー（shift=1以降）を使うのが基本
• 100ラインのクロスでエントリータイミングを判断するEAが作れる
• 移動平均線などと組み合わせることで、ダマシを減らしてシグナルの精度を高められる

モメンタムはシンプルながら奥が深い指標です。まずは今回のサンプルEAをストラテジーテスターで動かして、パラメータを変えながら挙動を確認してみてください。実際に手を動かすことで、理解が一気に深まりますよ！

投稿 【MQL4入門】iMomentum関数の使い方を徹底解説！モメンタムで相場の勢いを判定するEAを作ろう は 自動売買を作ろう！ に最初に表示されました。

MQL4には、ADXの値を簡単に取得できるiADX()関数が用意されています。この記事では、iADX()関数のパラメーターを一つひとつ解説し、実際にEAで使えるサンプルコードまで紹介します。

ADXインジケーターとは？

ADXは、J. Welles Wilder Jr.（ワイルダー）が開発したテクニカル指標で、トレンドの「強さ」を0〜100の数値で表すものです。トレンドの方向（上昇・下降）ではなく、「どれくらい強いトレンドが出ているか」を測定します。

ADXは以下の3本のラインで構成されています。

• ADX（メインライン） — トレンドの強さを示す（値が大きいほどトレンドが強い）
• +DI（プラス方向指標） — 上昇の勢いを示す
• -DI（マイナス方向指標） — 下降の勢いを示す

一般的には、ADXが25以上でトレンドが発生していると判断します。また、+DIが-DIより上にあれば上昇トレンド、-DIが+DIより上にあれば下降トレンドと判断できます。

iADX()関数の書式とパラメーター

MQL4のiADX()関数の書式は以下の通りです。

double iADX(
    string   symbol,          // 通貨ペア名
    int      timeframe,       // 時間足
    int      period,          // 計算期間
    int      applied_price,   // 適用価格
    int      mode,            // 取得するライン
    int      shift            // シフト（何本前の足か）
);

各パラメーターの意味を詳しく見ていきましょう。

symbol（通貨ペア名）

対象の通貨ペアを文字列で指定します。現在のチャートの通貨ペアを使う場合はNULLまたはSymbol()と記述します。

timeframe（時間足）

計算に使う時間足を指定します。現在のチャートの時間足を使う場合は0またはPERIOD_CURRENTを指定します。他にもPERIOD_M1、PERIOD_H1、PERIOD_D1などが使えます。

period（計算期間）

ADXの計算期間です。ワイルダーが推奨した14がデフォルトとしてよく使われます。

applied_price（適用価格）

価格の種類を指定します。ADXでは通常PRICE_CLOSE（終値）を指定します。

mode（取得するライン）

ADXの3本のラインのうち、どれを取得するかを指定します。ここが最も重要なパラメーターです。

shift（シフト）

何本前の足のデータを取得するかを指定します。0が現在の足（形成中）、1が1本前の確定済み足です。EAのロジックでは、確定した値を使うために1以上を指定するのが一般的です。

基本的な値の取得方法

まずは、3本のラインの値をそれぞれ取得する基本コードを見てみましょう。

void OnTick()
{
    // 1本前の確定足からADXの各ラインを取得（期間14）
    double adxValue  = iADX(NULL, 0, 14, PRICE_CLOSE, MODE_MAIN,    1);
    double plusDI     = iADX(NULL, 0, 14, PRICE_CLOSE, MODE_PLUSDI,  1);
    double minusDI    = iADX(NULL, 0, 14, PRICE_CLOSE, MODE_MINUSDI,1);

    // ログに出力して確認
    Print("ADX=", DoubleToString(adxValue, 2),
          " +DI=", DoubleToString(plusDI, 2),
          " -DI=", DoubleToString(minusDI, 2));
}

このコードをEAに貼り付けてストラテジーテスターで実行すると、操作ログにADXの各値が表示されます。まずはここから試してみてください。

実践サンプル①：ADXをトレンドフィルターとして使う

ADXの最もポピュラーな使い方は、トレンドフィルターです。「ADXが一定値以上のときだけエントリーする」というルールを加えるだけで、レンジ相場での無駄なエントリーを減らせます。

// --- 入力パラメーター ---
input int    ADX_Period    = 14;     // ADX期間
input double ADX_Threshold = 25.0;   // トレンド判定のしきい値

void OnTick()
{
    double adxValue = iADX(NULL, 0, ADX_Period, PRICE_CLOSE, MODE_MAIN, 1);
    double plusDI    = iADX(NULL, 0, ADX_Period, PRICE_CLOSE, MODE_PLUSDI, 1);
    double minusDI   = iADX(NULL, 0, ADX_Period, PRICE_CLOSE, MODE_MINUSDI, 1);

    // トレンドが弱い場合は何もしない
    if(adxValue < ADX_Threshold)
    {
        // レンジ相場と判断 → エントリーしない
        return;
    }

    // +DI > -DI なら上昇トレンド
    if(plusDI > minusDI)
    {
        // ここに買いエントリーのロジックを記述
        Print("上昇トレンド検出！ ADX=", DoubleToString(adxValue, 2));
    }
    // -DI > +DI なら下降トレンド
    else if(minusDI > plusDI)
    {
        // ここに売りエントリーのロジックを記述
        Print("下降トレンド検出！ ADX=", DoubleToString(adxValue, 2));
    }
}

この仕組みを他の売買ロジック（移動平均線のクロスなど）と組み合わせることで、エントリー精度を高められます。

実践サンプル②：+DI/-DIクロスで売買するEA

ここでは、+DIと-DIのクロスをシグナルとして実際にエントリーを行うEAの完全なコードを紹介します。

売買ルール

• 買い条件：+DIが-DIを上抜け（ゴールデンクロス）＋ ADXがしきい値以上
• 売り条件：-DIが+DIを上抜け（デッドクロス）＋ ADXがしきい値以上
• 既に同方向のポジションがある場合はエントリーしない

//+------------------------------------------------------------------+
//| ADX Cross EA                                                      |
//+------------------------------------------------------------------+
#property strict

// --- 入力パラメーター ---
input int    ADX_Period    = 14;     // ADX期間
input double ADX_Threshold = 25.0;   // ADXしきい値
input double LotSize       = 0.1;    // ロットサイズ
input int    StopLossPips  = 50;     // ストップロス（pips）
input int    TakeProfitPips= 100;    // テイクプロフィット（pips）
input int    MagicNumber   = 12345;  // マジックナンバー

//+------------------------------------------------------------------+
//| pip補正値を取得する関数                                            |
//+------------------------------------------------------------------+
double PipPoint()
{
    if(Digits == 3 || Digits == 5)
        return Point * 10;
    else
        return Point;
}

//+------------------------------------------------------------------+
//| 指定方向のポジション数を数える関数                                  |
//+------------------------------------------------------------------+
int CountOrders(int orderType)
{
    int count = 0;
    for(int i = OrdersTotal() - 1; i >= 0; i--)
    {
        if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
        {
            if(OrderSymbol() == Symbol() && OrderMagicNumber() == MagicNumber)
            {
                if(OrderType() == orderType)
                    count++;
            }
        }
    }
    return count;
}

//+------------------------------------------------------------------+
//| OnTick - メイン処理                                                |
//+------------------------------------------------------------------+
void OnTick()
{
    // --- 1本前（確定足）の値 ---
    double adx_1      = iADX(NULL, 0, ADX_Period, PRICE_CLOSE, MODE_MAIN,    1);
    double plusDI_1    = iADX(NULL, 0, ADX_Period, PRICE_CLOSE, MODE_PLUSDI,  1);
    double minusDI_1  = iADX(NULL, 0, ADX_Period, PRICE_CLOSE, MODE_MINUSDI, 1);

    // --- 2本前の値（クロス判定に使用） ---
    double plusDI_2    = iADX(NULL, 0, ADX_Period, PRICE_CLOSE, MODE_PLUSDI,  2);
    double minusDI_2  = iADX(NULL, 0, ADX_Period, PRICE_CLOSE, MODE_MINUSDI, 2);

    double pip = PipPoint();

    // --- 買いシグナル判定 ---
    // 2本前は +DI <= -DI だったのに、1本前で +DI > -DI になった（ゴールデンクロス）
    bool buySignal  = (plusDI_2 <= minusDI_2) && (plusDI_1 > minusDI_1) && (adx_1 >= ADX_Threshold);

    // --- 売りシグナル判定 ---
    // 2本前は -DI <= +DI だったのに、1本前で -DI > +DI になった（デッドクロス）
    bool sellSignal = (minusDI_2 <= plusDI_2) && (minusDI_1 > plusDI_1) && (adx_1 >= ADX_Threshold);

    // --- 買いエントリー ---
    if(buySignal && CountOrders(OP_BUY) == 0)
    {
        double sl = Ask - StopLossPips * pip;
        double tp = Ask + TakeProfitPips * pip;
        int ticket = OrderSend(Symbol(), OP_BUY, LotSize, Ask, 3, sl, tp,
                               "ADX Cross Buy", MagicNumber, 0, clrBlue);
        if(ticket > 0)
            Print("買いエントリー成功 ADX=", DoubleToString(adx_1, 2),
                  " +DI=", DoubleToString(plusDI_1, 2),
                  " -DI=", DoubleToString(minusDI_1, 2));
        else
            Print("買いエントリー失敗 Error=", GetLastError());
    }

    // --- 売りエントリー ---
    if(sellSignal && CountOrders(OP_SELL) == 0)
    {
        double sl = Bid + StopLossPips * pip;
        double tp = Bid - TakeProfitPips * pip;
        int ticket = OrderSend(Symbol(), OP_SELL, LotSize, Bid, 3, sl, tp,
                               "ADX Cross Sell", MagicNumber, 0, clrRed);
        if(ticket > 0)
            Print("売りエントリー成功 ADX=", DoubleToString(adx_1, 2),
                  " +DI=", DoubleToString(plusDI_1, 2),
                  " -DI=", DoubleToString(minusDI_1, 2));
        else
            Print("売りエントリー失敗 Error=", GetLastError());
    }
}

コードのポイント解説

クロス判定の仕組み：2本前の足と1本前の足で+DIと-DIの大小関係が逆転したかどうかで判定しています。例えば、2本前は「+DI ≤ -DI」だったのに1本前で「+DI > -DI」になっていれば、+DIが-DIを上抜けた（ゴールデンクロス）と判断します。

pip補正（PipPoint関数）：3桁・5桁の通貨ペア（例：ドル円が110.123のように小数点3桁）では、Pointが0.001になります。pipsとして扱うにはPoint×10が必要なので、Digitsに応じて補正しています。

重複エントリー防止：CountOrders()関数で同方向のポジションが既にあるかチェックし、重複エントリーを防いでいます。マジックナンバーで他のEAのポジションと区別している点も実用的なテクニックです。

iADX()を使うときの注意点

1. 確定足の値を使おう

shift=0で取得する値は、現在形成中の足の値なので、ティックごとに変動します。売買判定にはshift=1以上（確定済みの足）の値を使うのが安定したロジックのコツです。

2. ADXは「方向」を示さない

ADXのメインラインはあくまで「トレンドの強さ」だけを示します。上昇・下降の方向は+DIと-DIの位置関係で判断する必要があります。ADXが高い＝上昇トレンドではない点に注意してください。

3. MQL5との違い

MQL4のiADX()は直接double値を返しますが、MQL5ではiADX()が「ハンドル」（整数値）を返し、実際の値はCopyBuffer()で配列にコピーして取得する仕組みに変わっています。MQL5に移行する際はコードの書き換えが必要になるので覚えておきましょう。

他のインジケーターとの組み合わせ

ADXは単体でも有用ですが、他のインジケーターと組み合わせるとさらに効果的です。

移動平均線（MA）+ ADX

MAのゴールデンクロス・デッドクロスをエントリーシグナルとし、ADXが25以上のときだけエントリーするフィルターとして使います。レンジ相場でのダマシを大幅に減らせます。

RSI + ADX

RSIの買われすぎ・売られすぎをシグナルとしつつ、ADXが低い（レンジ相場）ときだけ逆張りエントリーする手法です。ADXが高いとき（トレンド発生時）にはRSIの逆張りを控えることで、トレンドに逆らうリスクを回避できます。

マルチタイムフレーム分析

iADX()のtimeframe引数を変えれば、異なる時間足のADX値を取得できます。例えば、日足のADXでトレンドを確認し、1時間足で具体的なエントリータイミングを計る、といった使い方が可能です。

// 日足のADX値を取得
double adx_daily = iADX(NULL, PERIOD_D1, 14, PRICE_CLOSE, MODE_MAIN, 1);

// 1時間足の+DI/-DIを取得
double plusDI_H1  = iADX(NULL, PERIOD_H1, 14, PRICE_CLOSE, MODE_PLUSDI, 1);
double minusDI_H1 = iADX(NULL, PERIOD_H1, 14, PRICE_CLOSE, MODE_MINUSDI, 1);

// 日足でトレンドが出ていて、1時間足で+DI優勢なら買い
if(adx_daily >= 25 && plusDI_H1 > minusDI_H1)
{
    Print("マルチタイムフレーム分析：買い条件成立");
}

まとめ

この記事では、MQL4のiADX()関数の使い方を基礎から実践まで解説しました。ポイントを振り返りましょう。

• ADXはトレンドの「強さ」を0〜100で数値化するインジケーター
• iADX()関数のmode引数で、ADX本体・+DI・-DIの3つのラインを切り替えて取得する
• ADXが25以上でトレンド発生、+DIと-DIの位置関係でトレンドの方向を判定
• 売買判定には確定足（shift=1以上）の値を使うのが基本
• 他のインジケーターのトレンドフィルターとして組み合わせると効果的

ADXはシンプルながら非常に強力なインジケーターです。まずは基本の値取得から試して、自分のEAにトレンドフィルターとして組み込んでみてください。レンジ相場での無駄なエントリーが減り、トレード成績の改善が期待できるはずです！

投稿 【MQL4】iADX関数の使い方を徹底解説！ADXでトレンドの強さを判定するサンプルプログラム付き は 自動売買を作ろう！ に最初に表示されました。

MQL4には、ボラティリティ（価格変動の大きさ）を数値化できる便利な関数iATRが用意されています。ATR（Average True Range：アベレージ・トゥルー・レンジ）は、多くのプロトレーダーも活用している指標で、ストップロスの設定やエントリーフィルターなど、EA開発で大活躍します。

この記事では、iATR関数の基本的な使い方から、実践的なEAへの組み込み方まで、サンプルコード付きで徹底解説します！

ATR（アベレージ・トゥルー・レンジ）とは？

ATRを理解するには、まずTR（トゥルー・レンジ）を知る必要があります。TRは「そのローソク足の本当の値動き幅」を表すもので、次の3つの値のうち最も大きいものを採用します。

• 当日の高値 − 当日の安値（通常の値幅）
• 当日の高値 − 前日の終値の絶対値（上方向へのギャップを考慮）
• 当日の安値 − 前日の終値の絶対値（下方向へのギャップを考慮）

ATRは、このTRを指定した期間で平均化したものです。一般的には14期間がよく使われます。

ATRの値が大きいほど「ボラティリティが高い（値動きが激しい）」、小さいほど「ボラティリティが低い（値動きが穏やか）」と判断できます。なお、ATRはあくまで値動きの「大きさ」を示すものであり、方向（上昇・下降）は示しません。

iATR関数の基本構文

MQL4でATRの値を取得するには、iATR関数を使います。基本構文は以下の通りです。

double iATR(
    string symbol,      // 通貨ペア名
    int    timeframe,   // 時間足
    int    period,      // 平均期間
    int    shift        // シフト（何本前のバーか）
);

各引数の詳細を見ていきましょう。

基本的な使い方 ― ATR値を取得してみよう

まずは最もシンプルな使い方です。現在のチャートで14期間ATRの値を取得し、エキスパートログに出力してみましょう。

void OnTick()
{
    // 直近の確定バー（shift=1）のATR値を取得
    double atrValue = iATR(NULL, 0, 14, 1);

    // ログに出力
    Print("現在のATR(14) = ", DoubleToString(atrValue, 5));
}

ここで重要なポイントはshift=1を使っていることです。shift=0だと現在形成中のバー（まだ確定していない）の値を参照するため、ティックごとに値が変動してしまいます。EAのロジックでは、基本的にshift=1（直近の確定バー）を使うのが安定した判断につながります。

実践サンプル①：ATRベースの動的ストップロス＆テイクプロフィット

ATRの最も人気のある活用法の一つが、ボラティリティに応じてSL（ストップロス）とTP（テイクプロフィット）を動的に変える方法です。相場が激しく動いているときは広めに、穏やかなときは狭めに設定できます。

// --- 入力パラメータ ---
input int    ATR_Period    = 14;      // ATR期間
input double SL_Multiplier = 1.5;    // SLに使うATRの倍率
input double TP_Multiplier = 2.0;    // TPに使うATRの倍率
input double LotSize       = 0.1;    // ロットサイズ

void OnTick()
{
    // 既にポジションがあれば何もしない（簡略化のため）
    if(OrdersTotal() > 0) return;

    // ATR値を取得（確定バーを使用）
    double atr = iATR(NULL, 0, ATR_Period, 1);

    // ATRが0の場合は処理しない
    if(atr <= 0) return;

    // 動的なSL・TPを計算
    double sl_distance = atr * SL_Multiplier;
    double tp_distance = atr * TP_Multiplier;

    // 現在の価格を取得
    double askPrice = Ask;
    double bidPrice = Bid;

    // 買い注文の例
    double sl = askPrice - sl_distance;
    double tp = askPrice + tp_distance;

    // 小数点桁数を通貨ペアに合わせて丸める
    sl = NormalizeDouble(sl, Digits);
    tp = NormalizeDouble(tp, Digits);

    int ticket = OrderSend(
        Symbol(), OP_BUY, LotSize,
        askPrice, 3, sl, tp,
        "ATR-based SL/TP", 0, 0, clrBlue
    );

    if(ticket > 0)
    {
        Print("注文成功！ SL=", DoubleToString(sl, Digits),
              " TP=", DoubleToString(tp, Digits),
              " ATR=", DoubleToString(atr, 5));
    }
    else
    {
        Print("注文失敗: エラーコード=", GetLastError());
    }
}

この例では、ATRの1.5倍をストップロスに、2.0倍をテイクプロフィットに設定しています。こうすることで、ボラティリティが高い相場では自然とSL/TP幅が広がり、低い相場では狭まります。固定pipsのSL/TPと比べて、相場環境に柔軟に対応できるのが大きなメリットです。

実践サンプル②：ATRでボラティリティフィルターを作る

もう一つの活用法が、ボラティリティフィルターです。「ボラティリティが一定以上あるときだけトレードする」というフィルターを作ることで、値動きが小さすぎるレンジ相場でのムダなエントリーを避けられます。

// ボラティリティが十分かどうかを判定する関数
bool IsVolatilityEnough(int atrPeriod, int checkBars, double threshold)
{
    // 現在のATR
    double currentATR = iATR(NULL, 0, atrPeriod, 1);

    // 過去のATRの平均を計算
    double sumATR = 0;
    for(int i = 2; i <= checkBars + 1; i++)
    {
        sumATR += iATR(NULL, 0, atrPeriod, i);
    }
    double avgATR = sumATR / checkBars;

    // 平均に対する比率で判定
    if(avgATR <= 0) return false;

    double ratio = currentATR / avgATR;

    // 比率がしきい値以上ならボラティリティ十分と判定
    if(ratio >= threshold)
    {
        Print("ボラティリティOK: 現在ATR=", DoubleToString(currentATR, 5),
              " 平均ATR=", DoubleToString(avgATR, 5),
              " 比率=", DoubleToString(ratio, 2));
        return true;
    }

    return false;
}

// 使用例
void OnTick()
{
    // 過去20本のATR平均と比較して、0.8倍以上なら十分と判定
    if(!IsVolatilityEnough(14, 20, 0.8))
    {
        // ボラティリティが低いのでトレードしない
        return;
    }

    // ここにエントリーロジックを記述
    // ...
}

この関数は、直近のATRが過去の平均ATRに対してどの程度の比率かを計算し、指定したしきい値以上であれば「ボラティリティ十分」と判定します。レンジ相場で無駄にエントリーしてしまう問題を軽減できる、実用的なフィルターです。

iATR関数を使う際の注意点

① shift=1を基本にしよう

先ほども触れましたが、EA内でATR値をロジック判定に使うときはshift=1（直近の確定バー）を使いましょう。shift=0はティックごとに値が変わるため、バックテストとリアルトレードで結果が乖離する原因になります。

② ATR値をpipsに換算する方法

ATRの戻り値は「価格の値幅」です。pipsに換算したい場合は、以下のようにします。

double atr = iATR(NULL, 0, 14, 1);

// pipsに換算（3桁/5桁ブローカー対応）
double atrPips;
if(Digits == 3 || Digits == 5)
    atrPips = atr / (Point * 10);
else
    atrPips = atr / Point;

Print("ATR = ", DoubleToString(atrPips, 1), " pips");

多くのブローカーは5桁（例：USDJPY = 110.123）または3桁（例：USDJPY = 110.12の場合もあり）の価格表示を使っています。Digitsの値を確認してpips換算することで、どのブローカーでも正しく動作するコードになります。

③ マルチタイムフレームでの活用

iATR関数のtimeframe引数を使えば、現在のチャートとは異なる時間足のATRを取得できます。

// 日足のATRを5分足チャート上で取得
double dailyATR = iATR(NULL, PERIOD_D1, 14, 1);

// 4時間足のATRを取得
double h4ATR = iATR(NULL, PERIOD_H4, 14, 1);

Print("日足ATR=", DoubleToString(dailyATR, 5),
      " 4時間足ATR=", DoubleToString(h4ATR, 5));

例えば、5分足でスキャルピングEAを作りつつ、日足のATRでその日全体のボラティリティを確認する、という使い方ができます。上位足のボラティリティ情報を加味することで、より精度の高いトレード判断が可能になります。

まとめ

この記事では、MQL4のiATR関数を使ってATR（アベレージ・トゥルー・レンジ）を取得・活用する方法を解説しました。最後にポイントを振り返りましょう。

• ATRはボラティリティ（値動きの大きさ）を数値化した指標で、方向性は示さない
• iATR関数は4つの引数（symbol, timeframe, period, shift）で手軽にATR値を取得できる
• EAのロジックではshift=1（確定バー）を使うのが基本
• 動的SL/TPに活用すれば、相場のボラティリティに応じた柔軟なリスク管理が可能
• ボラティリティフィルターとして使えば、レンジ相場でのムダなエントリーを回避できる
• pips換算やマルチタイムフレーム対応も忘れずに実装しよう

ATRは地味に見えるかもしれませんが、EA開発においては非常に汎用性の高い指標です。ストップロス、テイクプロフィット、ロットサイズの計算、エントリーフィルターなど、さまざまな場面で活躍します。ぜひ自分のEAに組み込んで、ボラティリティを味方につけてください！

投稿 【MQL4】iATR関数の使い方を徹底解説！ATR（アベレージ・トゥルー・レンジ）でボラティリティを味方につけよう は 自動売買を作ろう！ に最初に表示されました。

この記事では、iCCI関数の基本的な使い方からパラメータの意味、そしてCCIのクロスを利用した実践的なEAの作成方法まで、ステップバイステップで解説していきます。

CCI（商品チャネル指数）とは？

CCIは1980年にドナルド・ランバート氏が開発したモメンタム系オシレーターです。もともとは商品先物市場向けに作られましたが、現在ではFXや株式など幅広い市場で使われています。

CCIの特徴は、RSIやストキャスティクスのように0〜100の範囲に収まるのではなく、上下に制限なく動く点です。一般的には以下の基準で判断します。

• +100を上回る：買われすぎ（上昇トレンドが強い）
• -100を下回る：売られすぎ（下降トレンドが強い）
• 0ライン：トレンドの方向転換の目安

CCIの計算式

CCIの計算式は以下の通りです。

CCI = (TP - MA) / (0.015 × MD)

// TP（ティピカルプライス）= (高値 + 安値 + 終値) / 3
// MA = TPの単純移動平均（期間N）
// MD = TPと移動平均の平均偏差
// 0.015 = CCI値の約70〜80%が±100以内に収まるように設定された定数

計算式を覚える必要はありませんが、TPをベースにしていることは頭に入れておきましょう。iCCI関数のapplied_priceパラメータに関わってきます。

iCCI関数の構文

MQL4でCCIの値を取得するには、iCCI関数を使います。構文は以下の通りです。

double iCCI(
   string       symbol,          // 通貨ペア名
   int          timeframe,       // 時間足
   int          period,          // 平均期間
   int          applied_price,   // 適用価格
   int          shift            // シフト（何本前の足か）
);

パラメータ一覧

applied_price（適用価格）の定数一覧

CCIの計算に使用する価格タイプを指定します。デフォルトのCCIではティピカルプライスが使われます。

チャート上にCCIインジケーターを表示して比較する場合は、applied_priceを同じ設定にしないと値がずれるので注意してください。標準のCCIはPRICE_TYPICALを使用しています。

基本的な使い方

まずは最もシンプルな使い方を見てみましょう。1本前の確定足のCCI値を取得してコメントに表示する例です。

void OnTick()
{
   // 1本前の確定足のCCI（期間14、ティピカルプライス）を取得
   double cciValue = iCCI(NULL, 0, 14, PRICE_TYPICAL, 1);
   
   // チャート上にCCI値を表示
   Comment("CCI(14) = ", DoubleToString(cciValue, 2));
}

ポイント：shiftに1を指定して確定足の値を使うのが基本です。0（現在の足）はティックごとに値が変動するため、売買シグナルの判定には向きません。

CCIクロスで売買するEAを作ろう

ここからが本番です。CCIが-100を下から上にクロスしたら買い、+100を上から下にクロスしたら売り、0ラインクロスで決済するEAを作成します。

トレードロジックの整理

• 買いエントリー：CCI（1本前）が-100以上 かつ CCI（2本前）が-100未満 → -100を上抜け
• 売りエントリー：CCI（1本前）が+100以下 かつ CCI（2本前）が+100超 → +100を下抜け
• 買いポジション決済：CCIが0を下回った時
• 売りポジション決済：CCIが0を上回った時

完全なEAコード

//+------------------------------------------------------------------+
//| CCI Cross EA                                                       |
//+------------------------------------------------------------------+
#property strict

// 入力パラメータ
input int    CCI_Period      = 14;            // CCI期間
input double LotSize         = 0.1;           // ロットサイズ
input int    StopLoss        = 100;           // ストップロス（pips）
input int    TakeProfit      = 200;           // テイクプロフィット（pips）
input int    MagicNumber     = 20240101;      // マジックナンバー

//+------------------------------------------------------------------+
//| Expert tick function                                               |
//+------------------------------------------------------------------+
void OnTick()
{
   // CCI値を取得（確定足を使用）
   double cci1 = iCCI(NULL, 0, CCI_Period, PRICE_TYPICAL, 1); // 1本前
   double cci2 = iCCI(NULL, 0, CCI_Period, PRICE_TYPICAL, 2); // 2本前
   
   // 現在のポジション状態を確認
   int buyCount  = CountPositions(OP_BUY);
   int sellCount = CountPositions(OP_SELL);
   
   // --- 決済ロジック ---
   // 買いポジション保有中：CCIが0を下回ったら決済
   if(buyCount > 0 && cci1 < 0)
   {
      ClosePositions(OP_BUY);
   }
   
   // 売りポジション保有中：CCIが0を上回ったら決済
   if(sellCount > 0 && cci1 > 0)
   {
      ClosePositions(OP_SELL);
   }
   
   // --- エントリーロジック ---
   // ポジションがない場合のみエントリー
   if(buyCount == 0 && sellCount == 0)
   {
      // 買いシグナル：CCIが-100を下から上にクロス
      if(cci2 < -100 && cci1 >= -100)
      {
         double sl = (StopLoss > 0)   ? Ask - StopLoss * Point * 10 : 0;
         double tp = (TakeProfit > 0)  ? Ask + TakeProfit * Point * 10 : 0;
         
         int ticket = OrderSend(Symbol(), OP_BUY, LotSize, Ask, 30, sl, tp,
                                "CCI Buy", MagicNumber, 0, clrBlue);
         if(ticket < 0)
            Print("Buy OrderSend error: ", GetLastError());
      }
      
      // 売りシグナル：CCIが+100を上から下にクロス
      if(cci2 > 100 && cci1 <= 100)
      {
         double sl = (StopLoss > 0)   ? Bid + StopLoss * Point * 10 : 0;
         double tp = (TakeProfit > 0)  ? Bid - TakeProfit * Point * 10 : 0;
         
         int ticket = OrderSend(Symbol(), OP_SELL, LotSize, Bid, 30, sl, tp,
                                "CCI Sell", MagicNumber, 0, clrRed);
         if(ticket < 0)
            Print("Sell OrderSend error: ", GetLastError());
      }
   }
}

//+------------------------------------------------------------------+
//| 指定タイプのポジション数をカウント                                    |
//+------------------------------------------------------------------+
int CountPositions(int type)
{
   int count = 0;
   for(int i = OrdersTotal() - 1; i >= 0; i--)
   {
      if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
      {
         if(OrderSymbol() == Symbol() && OrderMagicNumber() == MagicNumber && OrderType() == type)
            count++;
      }
   }
   return count;
}

//+------------------------------------------------------------------+
//| 指定タイプのポジションを全て決済                                      |
//+------------------------------------------------------------------+
void ClosePositions(int type)
{
   for(int i = OrdersTotal() - 1; i >= 0; i--)
   {
      if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
      {
         if(OrderSymbol() == Symbol() && OrderMagicNumber() == MagicNumber && OrderType() == type)
         {
            double closePrice = (type == OP_BUY) ? Bid : Ask;
            if(!OrderClose(OrderTicket(), OrderLots(), closePrice, 30, clrYellow))
               Print("OrderClose error: ", GetLastError());
         }
      }
   }
}

コードのポイント解説

① MagicNumberの活用

MagicNumberを使うことで、このEAが出した注文だけを識別できます。手動注文や他のEAの注文を誤って決済してしまう事故を防げます。

② 確定足（shift=1, 2）でクロスを検出

2本前と1本前の確定足を比較してクロスを検出しています。現在の足（shift=0）を使うと、ティックごとに値が変わるためシグナルが不安定になります。

③ 決済を逆方向ではなく0ラインで行う

CCIが0ラインをクロスした時点で決済することで、利益の取りこぼしを減らす設計になっています。もちろん、SL/TPによる自動決済も併用しています。

応用テクニック：マルチタイムフレーム分析

iCCI関数の第2引数（timeframe）を変えるだけで、上位足のCCIをフィルターとして使うことができます。例えば、日足のCCIの方向に合わせてエントリーを絞り込む手法です。

// 上位足（日足）のCCIでトレンド方向を判定
double cciDaily = iCCI(NULL, PERIOD_D1, 14, PRICE_TYPICAL, 1);

// 現在の時間足のCCIでエントリータイミングを判定
double cciCurrent1 = iCCI(NULL, 0, 14, PRICE_TYPICAL, 1);
double cciCurrent2 = iCCI(NULL, 0, 14, PRICE_TYPICAL, 2);

// 日足CCIが0以上（上昇傾向）の時だけ買いエントリー
if(cciDaily > 0 && cciCurrent2 < -100 && cciCurrent1 >= -100)
{
   // 買いエントリー処理
}

// 日足CCIが0以下（下降傾向）の時だけ売りエントリー
if(cciDaily < 0 && cciCurrent2 > 100 && cciCurrent1 <= 100)
{
   // 売りエントリー処理
}

上位足のトレンド方向に逆らわないことで、ダマシのシグナルを大幅に減らすことが期待できます。

iCCI関数を使う際の注意点

1. applied_priceの不一致に注意

チャート上に表示しているCCIインジケーターと、iCCI関数で指定したapplied_priceが異なると、値がずれます。検証時は必ず同じ設定にしましょう。標準のCCIはPRICE_TYPICALです。

2. レンジ相場での連続シグナルに注意

CCIはモメンタム指標なので、レンジ相場では±100ラインを頻繁に行き来し、ダマシが多発します。移動平均線やADXなどのトレンドフィルターを組み合わせることをおすすめします。

3. 計算に必要なバー数

CCIの計算には、指定した期間分のローソク足データが必要です。チャートのバー数が少ないと正確な値が得られません。バックテスト時は十分なヒストリカルデータを用意してください。

まとめ

今回はMQL4のiCCI関数の使い方を、基本から実践的なEA作成まで解説しました。

• iCCI関数は5つのパラメータでCCIの値を簡単に取得できる
• ±100ラインのクロスをエントリーシグナルに、0ラインクロスを決済シグナルに使うのが王道的な手法
• 確定足（shift=1以上）を使ってシグナル判定するのが安定した運用のコツ
• マルチタイムフレーム分析で上位足のトレンド方向にフィルターをかけると精度が向上する
• applied_priceはチャート上のインジケーターと合わせることを忘れずに

CCIはシンプルながら奥が深いインジケーターです。まずはサンプルEAをストラテジーテスターで動かしてみて、パラメータを変えながらCCIの振る舞いを体感してみてください！

投稿 【MQL4】iCCI関数の使い方を徹底解説！CCI（商品チャネル指数）でトレンド転換を捉えるEAを作ろう は 自動売買を作ろう！ に最初に表示されました。

この記事では、iStochastic関数の書式・引数をひとつずつ丁寧に解説し、最後にストキャスティクスのクロスで売買する実践的なEAサンプルを紹介します。

ストキャスティクスとは？

ストキャスティクス（Stochastic Oscillator）は、一定期間の価格レンジの中で現在の価格がどの位置にあるかを0〜100の数値で示すテクニカル指標です。

3本のラインを理解しよう

ストキャスティクスには以下の3種類のラインがあります。

• %K（Fast %K）：直近の価格が一定期間の高値・安値レンジのどこに位置するかを示す、最も感度の高いライン
• %D（Fast %D / Slow %K）：%Kを移動平均で平滑化したライン。MetaTrader4のストキャスティクスではこれがメインラインになります
• Slow %D（シグナルライン）：%Dをさらに移動平均で平滑化したライン

80と20のレベルライン

一般的に、ストキャスティクスの値が80以上になると「買われすぎ」、20以下になると「売られすぎ」と判断します。この水準でのラインのクロスが売買シグナルとしてよく使われます。

iStochastic関数の書式と引数を完全解説

iStochastic関数の書式は以下のとおりです。

double iStochastic(
   string       symbol,        // ① 通貨ペア
   int          timeframe,     // ② 時間足
   int          Kperiod,       // ③ %K期間
   int          Dperiod,       // ④ %D期間
   int          slowing,       // ⑤ スローイング
   int          method,        // ⑥ 移動平均の種類
   int          price_field,   // ⑦ 価格フィールド
   int          mode,          // ⑧ 取得するライン
   int          shift          // ⑨ シフト（何本前のバーか）
);

引数が9つもあるので少し多く感じますが、一つずつ見ていきましょう。

① symbol（通貨ペア）

値を取得したい通貨ペアを文字列で指定します。現在のチャートの通貨ペアを使う場合はNULLまたはSymbol()と書きます。

② timeframe（時間足）

時間足を定数で指定します。現在のチャートの時間足を使う場合は0またはPERIOD_CURRENTと書きます。主な定数は以下のとおりです。

③ Kperiod（%K期間）

%Kラインの計算に使う期間です。一般的には5や14がよく使われます。

④ Dperiod（%D期間）

%Kを平滑化して%Dを求める際の移動平均の期間です。一般的には3がよく使われます。

⑤ slowing（スローイング）

スローストキャスティクスのスローイング値です。1にするとファスト、3にするとスローストキャスティクスになります。通常は3を指定します。

⑥ method（移動平均の種類）

%Dラインの平滑化に使用する移動平均の種類を指定します。

⑦ price_field（価格フィールド）

ストキャスティクスの計算に使う価格の種類です。

通常は0（高値/安値）を使います。

⑧ mode（取得するライン）

どのラインの値を取得するかを指定します。

⑨ shift（シフト）

何本前のバーの値を取得するかを指定します。0で現在のバー、1で1本前のバー（確定済み）です。

基本的な使い方

まずはストキャスティクスの値を取得してチャートに表示するシンプルなコードを見てみましょう。

#property strict

void OnTick()
{
   // メインライン（%D）を取得 - 1本前の確定バー
   double stochMain = iStochastic(NULL, 0, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 1);

   // シグナルライン（Slow %D）を取得 - 1本前の確定バー
   double stochSignal = iStochastic(NULL, 0, 5, 3, 3, MODE_SMA, 0, MODE_SIGNAL, 1);

   // チャートに表示
   Comment("Stochastic Main: ", DoubleToString(stochMain, 2),
           "\nStochastic Signal: ", DoubleToString(stochSignal, 2));
}

このコードでは、期間5・3・3のスローストキャスティクス（SMA）のメインラインとシグナルラインの値を取得し、Comment関数でチャート左上に表示しています。shift=1を指定しているので、確定済みの1本前のバーの値を取得しています。

実践サンプルEA ― ストキャスティクスのクロスで売買

ここからは、ストキャスティクスのゴールデンクロス（買いシグナル）とデッドクロス（売りシグナル）で売買する実践的なEAを作ってみましょう。

売買ルール

• 買いエントリー：ストキャスティクスが20以下のゾーンで、メインラインがシグナルラインを下から上にクロス（ゴールデンクロス）
• 売りエントリー：ストキャスティクスが80以上のゾーンで、メインラインがシグナルラインを上から下にクロス（デッドクロス）
• 既にポジションがある場合は新規エントリーしない

EAの完全なコード

//+------------------------------------------------------------------+
//|                                          StochasticCrossEA.mq4   |
//|                         ストキャスティクス クロスEA サンプル        |
//+------------------------------------------------------------------+
#property strict

// --- 入力パラメータ ---
input int    KPeriod      = 5;       // %K期間
input int    DPeriod      = 3;       // %D期間
input int    Slowing      = 3;       // スローイング
input double UpperLevel   = 80.0;    // 上限レベル（売られすぎ判定）
input double LowerLevel   = 20.0;    // 下限レベル（買われすぎ判定）
input double LotSize      = 0.1;     // ロットサイズ
input int    StopLoss     = 100;     // ストップロス（pips）
input int    TakeProfit   = 200;     // テイクプロフィット（pips）
input int    MagicNumber  = 12345;   // マジックナンバー

// --- 新バー判定用変数 ---
datetime lastBarTime = 0;

//+------------------------------------------------------------------+
//| Expert initialization function                                     |
//+------------------------------------------------------------------+
int OnInit()
{
   Print("StochasticCrossEA が初期化されました");
   return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| 新しいバーが生成されたか判定する関数                                  |
//+------------------------------------------------------------------+
bool IsNewBar()
{
   datetime currentBarTime = iTime(NULL, 0, 0);
   if(lastBarTime != currentBarTime)
   {
      lastBarTime = currentBarTime;
      return true;
   }
   return false;
}

//+------------------------------------------------------------------+
//| 現在のポジション数を取得する関数                                     |
//+------------------------------------------------------------------+
int CountPositions(int type)
{
   int count = 0;
   for(int i = OrdersTotal() - 1; i >= 0; i--)
   {
      if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
      {
         if(OrderSymbol() == Symbol() && OrderMagicNumber() == MagicNumber)
         {
            if(OrderType() == type)
               count++;
         }
      }
   }
   return count;
}

//+------------------------------------------------------------------+
//| Expert tick function                                               |
//+------------------------------------------------------------------+
void OnTick()
{
   // 新しいバーが確定したときだけ処理
   if(!IsNewBar())
      return;

   // --- ストキャスティクスの値を取得 ---
   // 1本前（確定済み）のメインライン
   double mainCurr   = iStochastic(NULL, 0, KPeriod, DPeriod, Slowing,
                                    MODE_SMA, 0, MODE_MAIN, 1);
   // 1本前（確定済み）のシグナルライン
   double signalCurr = iStochastic(NULL, 0, KPeriod, DPeriod, Slowing,
                                    MODE_SMA, 0, MODE_SIGNAL, 1);
   // 2本前のメインライン
   double mainPrev   = iStochastic(NULL, 0, KPeriod, DPeriod, Slowing,
                                    MODE_SMA, 0, MODE_MAIN, 2);
   // 2本前のシグナルライン
   double signalPrev = iStochastic(NULL, 0, KPeriod, DPeriod, Slowing,
                                    MODE_SMA, 0, MODE_SIGNAL, 2);

   // --- ゴールデンクロス判定（買いシグナル） ---
   bool goldenCross = (mainPrev < signalPrev) && (mainCurr > signalCurr);

   // --- デッドクロス判定（売りシグナル） ---
   bool deadCross = (mainPrev > signalPrev) && (mainCurr < signalCurr);

   // --- 買いエントリー ---
   if(goldenCross && mainCurr < LowerLevel && CountPositions(OP_BUY) == 0)
   {
      double sl = NormalizeDouble(Ask - StopLoss * Point, Digits);
      double tp = NormalizeDouble(Ask + TakeProfit * Point, Digits);

      int ticket = OrderSend(Symbol(), OP_BUY, LotSize, Ask, 3, sl, tp,
                              "Stoch GoldenCross", MagicNumber, 0, clrBlue);
      if(ticket > 0)
         Print("買い注文成功: チケット=", ticket);
      else
         Print("買い注文失敗: エラー=", GetLastError());
   }

   // --- 売りエントリー ---
   if(deadCross && mainCurr > UpperLevel && CountPositions(OP_SELL) == 0)
   {
      double sl = NormalizeDouble(Bid + StopLoss * Point, Digits);
      double tp = NormalizeDouble(Bid - TakeProfit * Point, Digits);

      int ticket = OrderSend(Symbol(), OP_SELL, LotSize, Bid, 3, sl, tp,
                              "Stoch DeadCross", MagicNumber, 0, clrRed);
      if(ticket > 0)
         Print("売り注文成功: チケット=", ticket);
      else
         Print("売り注文失敗: エラー=", GetLastError());
   }

   // --- チャート表示 ---
   Comment("Main[1]: ", DoubleToString(mainCurr, 2),
           "  Signal[1]: ", DoubleToString(signalCurr, 2),
           "\nMain[2]: ", DoubleToString(mainPrev, 2),
           "  Signal[2]: ", DoubleToString(signalPrev, 2));
}

サンプルコードのポイント解説

ポイント1：新バー判定で無駄な処理を防ぐ

IsNewBar()関数を使い、新しいバーが確定したタイミングでのみ売買判定を行っています。OnTick()はティックごとに呼ばれるため、そのまま処理すると同じバーで何度もシグナルを検出してしまいます。新バー判定を入れることで、確定した値に基づく安定したシグナル検出ができます。

ポイント2：2本のバーでクロスを検出する

クロスの判定には、1本前（shift=1）と2本前（shift=2）の値を比較しています。

// ゴールデンクロス：2本前は「メイン ＜ シグナル」→ 1本前は「メイン ＞ シグナル」
bool goldenCross = (mainPrev < signalPrev) && (mainCurr > signalCurr);

// デッドクロス：2本前は「メイン ＞ シグナル」→ 1本前は「メイン ＜ シグナル」
bool deadCross = (mainPrev > signalPrev) && (mainCurr < signalCurr);

shift=0（現在のバー）を使うと、バーが確定するまで値が変動し続けるため、誤ったシグナルが出る可能性があります。確定済みのshift=1とshift=2を使うのが安全です。

ポイント3：ゾーンフィルタでダマシを減らす

単純なクロスだけではダマシ（偽シグナル）が多くなります。そこで、買いはLowerLevel（20）以下のゾーン、売りはUpperLevel（80）以上のゾーンでのみエントリーするフィルタを入れています。売られすぎ・買われすぎの極端な領域でのクロスに絞ることで、シグナルの精度を高めています。

カスタマイズのヒント

マルチタイムフレーム分析

iStochastic関数の第2引数（timeframe）を変えることで、異なる時間足のストキャスティクスを取得できます。例えば、日足のトレンド方向を確認してからエントリーするといった使い方が可能です。

// 日足のストキャスティクスを取得
double dailyMain = iStochastic(NULL, PERIOD_D1, 5, 3, 3, MODE_SMA, 0, MODE_MAIN, 1);

// 日足が50以上なら上昇傾向 → 買いのみエントリーする、など
if(dailyMain > 50.0 && goldenCross && mainCurr < LowerLevel)
{
   // 買いエントリー処理
}

他のインジケーターとの併用

ストキャスティクス単体よりも、移動平均線（iMA関数）やRSI（iRSI関数）など他のインジケーターと組み合わせることで、より信頼性の高い売買ルールを構築できます。例えば、移動平均線の上にいるときだけ買いシグナルを採用する、といったフィルタが考えられます。

ストラテジーテスターで最適化

KPeriod、DPeriod、Slowing、UpperLevel、LowerLevelなどのパラメータは、MetaTraderのストラテジーテスターで最適化できます。input変数として宣言しているので、テスターの最適化機能でベストな組み合わせを探してみましょう。ただし、過剰最適化（カーブフィッティング）には注意が必要です。

まとめ

この記事で学んだポイントを整理します。

1. iStochastic関数は9つの引数を持ち、MQL4からストキャスティクスの値を取得できる関数です
2. MODE_MAINでメインライン（%D）、MODE_SIGNALでシグナルライン（Slow %D）を取得します
3. price_fieldは通常0（高値/安値ベース）を使い、1（終値ベース）との違いを理解しておきましょう
4. クロス判定にはshift=1とshift=2の確定済みバーを使うのが安全です
5. 80/20のゾーンフィルタやマルチタイムフレーム分析を組み合わせることで、ダマシを減らして精度を向上させることができます

ストキャスティクスはシンプルながら強力なオシレーター指標です。まずは今回のサンプルEAをストラテジーテスターで動かして、パラメータを変えながら挙動を確認してみてください。実際に手を動かすことで、iStochastic関数の使い方がしっかり身につくはずです！

投稿 【MQL4】iStochastic関数の使い方を完全解説！ストキャスティクスを使ったEAサンプル付き は 自動売買を作ろう！ に最初に表示されました。

この記事では、MQL4のiMACD関数の書式・引数の意味から、ゴールデンクロス・デッドクロスの判定ロジック、そして実際に動くEAのサンプルコードまで、ステップバイステップで解説します。初心者の方でも、この記事を読み終える頃にはMACDを使ったEAの原型が作れるようになるはずです。

MACDのおさらい

コードの話に入る前に、MACD（Moving Average Convergence Divergence）の基本をおさらいしておきましょう。MACDは以下の3つの要素で構成されます。

MACDの3つの構成要素

• メインライン（MACDライン）：短期EMA（通常12期間）と長期EMA（通常26期間）の差
• シグナルライン：メインラインのEMA（通常9期間）
• ヒストグラム：メインライン − シグナルラインの差をバーで表示したもの

基本的な売買シグナル

• ゴールデンクロス（買いシグナル）：メインラインがシグナルラインを下から上に抜ける
• デッドクロス（売りシグナル）：メインラインがシグナルラインを上から下に抜ける

このクロスをプログラムで検出するのが、MACD系EAの基本中の基本です。

iMACD関数の書式と引数

MQL4でMACDの値を取得するには、iMACD関数を使います。書式は以下のとおりです。

double iMACD(
   string       symbol,           // 通貨ペア名
   int          timeframe,        // 時間足
   int          fast_ema_period,  // 短期EMAの期間
   int          slow_ema_period,  // 長期EMAの期間
   int          signal_period,    // シグナルラインの期間
   int          applied_price,    // 適用価格
   int          mode,             // 取得するライン
   int          shift             // シフト（何本前のバーか）
);

各引数の詳細

modeパラメータの値

modeには以下の2つの定数を指定できます。

• MODE_MAIN（0）：MACDメインラインの値を返す
• MODE_SIGNAL（1）：シグナルラインの値を返す

なお、ヒストグラムの値は直接取得する定数がありません。メインライン − シグナルラインを自分で計算して求めます。

適用価格（applied_price）の定数一覧

特別な理由がなければ、PRICE_CLOSE（終値）を使うのが一般的です。

基本的な使い方

まずは最もシンプルな使い方を見てみましょう。現在のチャートでMACDのメインラインとシグナルラインの値を取得するコードです。

void OnTick()
{
   // 1本前の確定バーからMACDメインラインの値を取得
   double macdMain = iMACD(NULL, 0, 12, 26, 9, PRICE_CLOSE, MODE_MAIN, 1);
   
   // 1本前の確定バーからシグナルラインの値を取得
   double macdSignal = iMACD(NULL, 0, 12, 26, 9, PRICE_CLOSE, MODE_SIGNAL, 1);
   
   // ヒストグラムの値を計算
   double histogram = macdMain - macdSignal;
   
   // ログに出力して確認
   Print("MACD Main: ", macdMain, " Signal: ", macdSignal, " Histogram: ", histogram);
}

ポイント：shiftに1を指定しているのは、「1本前の確定したバー」の値を取得するためです。shift=0は現在形成中のバーなので値が変動します。売買判定にはshift=1以降の確定した値を使うのが基本です。

MACDクロス判定ロジック

MACDのゴールデンクロス・デッドクロスを判定するには、1本前と2本前のバーの値を比較します。

// --- 1本前のバー（直近の確定バー）---
double macdMain1   = iMACD(NULL, 0, 12, 26, 9, PRICE_CLOSE, MODE_MAIN, 1);
double macdSignal1 = iMACD(NULL, 0, 12, 26, 9, PRICE_CLOSE, MODE_SIGNAL, 1);

// --- 2本前のバー ---
double macdMain2   = iMACD(NULL, 0, 12, 26, 9, PRICE_CLOSE, MODE_MAIN, 2);
double macdSignal2 = iMACD(NULL, 0, 12, 26, 9, PRICE_CLOSE, MODE_SIGNAL, 2);

// ゴールデンクロス判定：2本前ではメインがシグナル以下 → 1本前でメインがシグナルを超えた
bool goldenCross = (macdMain2 <= macdSignal2) && (macdMain1 > macdSignal1);

// デッドクロス判定：2本前ではメインがシグナル以上 → 1本前でメインがシグナルを下回った
bool deadCross = (macdMain2 >= macdSignal2) && (macdMain1 < macdSignal1);

この「2時点を比較してクロスを検出する」パターンは、移動平均線やRSIなど他のインジケーターでも応用できる重要なテクニックです。

実践！MACDクロスEAのサンプルコード

ここからは、MACDのゴールデンクロスで買い、デッドクロスで売り（ドテン方式）のEAを作ってみましょう。実際にMT4で動作する完全なコードです。

//+------------------------------------------------------------------+
//|                                              MACD_Cross_EA.mq4   |
//|                        MACDクロスで売買するシンプルなEA            |
//+------------------------------------------------------------------+
#property strict

// --- 入力パラメータ ---
input int    FastEMA        = 12;          // 短期EMA期間
input int    SlowEMA        = 26;          // 長期EMA期間
input int    SignalPeriod    = 9;           // シグナル期間
input double LotSize        = 0.1;         // ロット数
input int    MagicNumber    = 20240101;    // マジックナンバー
input int    Slippage       = 3;           // スリッページ（ポイント）

//+------------------------------------------------------------------+
//| 新しいバーが形成されたか判定する関数                                |
//+------------------------------------------------------------------+
bool IsNewBar()
{
   static datetime lastBarTime = 0;
   datetime currentBarTime = iTime(NULL, 0, 0);
   
   if(lastBarTime != currentBarTime)
   {
      lastBarTime = currentBarTime;
      return true;
   }
   return false;
}

//+------------------------------------------------------------------+
//| 自分のEAが持つポジションの種類を返す関数                           |
//| 戻り値: 1=買いポジあり, -1=売りポジあり, 0=ポジなし                |
//+------------------------------------------------------------------+
int GetMyPosition()
{
   for(int i = OrdersTotal() - 1; i >= 0; i--)
   {
      if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
      {
         if(OrderSymbol() == Symbol() && OrderMagicNumber() == MagicNumber)
         {
            if(OrderType() == OP_BUY)  return 1;
            if(OrderType() == OP_SELL) return -1;
         }
      }
   }
   return 0;
}

//+------------------------------------------------------------------+
//| 自分のEAが持つポジションを全決済する関数                           |
//+------------------------------------------------------------------+
void CloseMyPositions(int posType)
{
   for(int i = OrdersTotal() - 1; i >= 0; i--)
   {
      if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
      {
         if(OrderSymbol() == Symbol() && OrderMagicNumber() == MagicNumber)
         {
            if(posType == 1 && OrderType() == OP_BUY)
               OrderClose(OrderTicket(), OrderLots(), Bid, Slippage, clrNone);
            if(posType == -1 && OrderType() == OP_SELL)
               OrderClose(OrderTicket(), OrderLots(), Ask, Slippage, clrNone);
         }
      }
   }
}

//+------------------------------------------------------------------+
//| メインのティック処理                                               |
//+------------------------------------------------------------------+
void OnTick()
{
   // 新しいバーが形成されたときだけ処理する
   if(!IsNewBar()) return;
   
   // --- MACDの値を取得 ---
   double macdMain1   = iMACD(NULL, 0, FastEMA, SlowEMA, SignalPeriod, PRICE_CLOSE, MODE_MAIN, 1);
   double macdSignal1 = iMACD(NULL, 0, FastEMA, SlowEMA, SignalPeriod, PRICE_CLOSE, MODE_SIGNAL, 1);
   double macdMain2   = iMACD(NULL, 0, FastEMA, SlowEMA, SignalPeriod, PRICE_CLOSE, MODE_MAIN, 2);
   double macdSignal2 = iMACD(NULL, 0, FastEMA, SlowEMA, SignalPeriod, PRICE_CLOSE, MODE_SIGNAL, 2);
   
   // --- クロス判定 ---
   bool goldenCross = (macdMain2 <= macdSignal2) && (macdMain1 > macdSignal1);
   bool deadCross   = (macdMain2 >= macdSignal2) && (macdMain1 < macdSignal1);
   
   // --- 現在のポジション状態を取得 ---
   int myPos = GetMyPosition();
   
   // --- ゴールデンクロス → 買いエントリー ---
   if(goldenCross)
   {
      // 売りポジションがあれば先に決済
      if(myPos == -1) CloseMyPositions(-1);
      
      // 買いポジションがなければ新規注文
      if(GetMyPosition() != 1)
      {
         int ticket = OrderSend(Symbol(), OP_BUY, LotSize, Ask, Slippage, 0, 0,
                                "MACD GC Buy", MagicNumber, 0, clrBlue);
         if(ticket < 0)
            Print("Buy OrderSend Error: ", GetLastError());
         else
            Print("Buy Order Success! Ticket: ", ticket);
      }
   }
   
   // --- デッドクロス → 売りエントリー ---
   if(deadCross)
   {
      // 買いポジションがあれば先に決済
      if(myPos == 1) CloseMyPositions(1);
      
      // 売りポジションがなければ新規注文
      if(GetMyPosition() != -1)
      {
         int ticket = OrderSend(Symbol(), OP_SELL, LotSize, Bid, Slippage, 0, 0,
                                "MACD DC Sell", MagicNumber, 0, clrRed);
         if(ticket < 0)
            Print("Sell OrderSend Error: ", GetLastError());
         else
            Print("Sell Order Success! Ticket: ", ticket);
      }
   }
}

サンプルEAのポイント解説

• IsNewBar関数：新しいバーが形成されたときだけ処理を実行します。これにより無駄な重複注文を防ぎます。
• MagicNumber：このEAが出した注文を識別するための番号です。他のEAや手動注文と区別できます。
• ドテン方式：ゴールデンクロスで買いに転換、デッドクロスで売りに転換する仕組みです。反対ポジションを先に決済してから新規注文を出します。
• GetMyPosition関数：自分のEAが持つポジションの状態を調べる関数です。ポジション管理はEA開発で必須のテクニックです。

応用：ゼロラインフィルターでダマシを減らす

MACDクロスだけだと「ダマシ」（偽のシグナル）が多くなりがちです。精度を上げるテクニックとして、ゼロラインフィルターがあります。

考え方はシンプルです。

• 買いシグナル：ゴールデンクロス かつ MACDメインラインがゼロより下で発生したとき（底からの反転を狙う）
• 売りシグナル：デッドクロス かつ MACDメインラインがゼロより上で発生したとき（天井からの反転を狙う）

コードに組み込むなら、クロス判定の条件に1行追加するだけです。

// ゼロラインフィルター付きのゴールデンクロス判定
bool filteredGoldenCross = goldenCross && (macdMain1 < 0);

// ゼロラインフィルター付きのデッドクロス判定
bool filteredDeadCross = deadCross && (macdMain1 > 0);

たった1行の条件追加ですが、トレンドの初動を捉えやすくなり、レンジ相場でのダマシを軽減できます。バックテストで効果を確認してみてください。

注意点・よくあるつまずきポイント

1. MT4とMT5でMACDの表示が異なる

MT4のMACDインジケーターでは、メインラインがヒストグラム（バー）で表示され、シグナルラインが点線で表示されます。一方MT5では、メインラインもシグナルラインもラインで表示され、別途ヒストグラムが描画されます。見た目は違いますが、iMACD関数で取得できる値の意味は同じです。

2. ヒストグラムは自分で計算する

iMACD関数にはヒストグラムを直接取得するモードがありません。ヒストグラムが必要な場合は、以下のように計算してください。

double histogram = iMACD(NULL, 0, 12, 26, 9, PRICE_CLOSE, MODE_MAIN, 1)
                 - iMACD(NULL, 0, 12, 26, 9, PRICE_CLOSE, MODE_SIGNAL, 1);

3. マルチタイムフレーム分析に使える

iMACD関数の第2引数（timeframe）を変えれば、現在のチャートと違う時間足のMACDを取得できます。例えば、5分足チャート上で1時間足のMACDを確認してフィルターに使う、といった活用が可能です。

// 1時間足のMACDメインラインを取得
double macdH1 = iMACD(NULL, PERIOD_H1, 12, 26, 9, PRICE_CLOSE, MODE_MAIN, 1);

4. 引数の順番に注意

iMACD関数は引数が8つもあるため、順番を間違えやすいです。特にmodeとshiftを逆にするミスはよくあります。迷ったら公式リファレンスで確認する習慣をつけましょう。

まとめ

この記事では、MQL4のiMACD関数について以下のポイントを解説しました。

• iMACD関数は8つの引数を持ち、MACDのメインラインとシグナルラインの値を取得できる
• クロス判定はshift=1とshift=2の値を比較して行う
• EA開発では新規バー判定・マジックナンバー管理・ポジション管理関数が重要
• ゼロラインフィルターを追加するだけでダマシを軽減できる
• MT4とMT5でMACDの表示方法が異なる点に注意

今回のサンプルEAはシンプルな構成ですが、ストップロスやテイクプロフィット、トレーリングストップなどを追加していくことで、より実践的なEAに育てていくことができます。まずはバックテストで動作を確認し、少しずつカスタマイズしてみてください！

投稿 【MQL4】iMACD関数の使い方を徹底解説！MACDの値を取得してEAに組み込もう【サンプルコード付き】 は 自動売買を作ろう！ に最初に表示されました。

この記事では、EA開発で頻繁に使う5つの注文情報取得関数――OrderOpenPrice()・OrderStopLoss()・OrderTakeProfit()・OrderCloseTime()・OrderProfit()を、サンプルコード付きで徹底解説します。

前提知識：OrderSelect() で注文を選択してから使う

MQL4の注文情報取得関数には、共通のルールがあります。それは「必ず事前に OrderSelect() で注文を選択しておくこと」です。

OrderSelect() を呼ばずにこれらの関数を使うと、意図しない値が返ってきたり、前回選択した注文の情報が返ってしまったりします。これはMQL4初心者が最もハマりやすいポイントの一つです。

// 基本パターン：注文を選択してから情報を取得する
if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
{
    double openPrice = OrderOpenPrice();   // エントリー価格
    double sl        = OrderStopLoss();    // 損切り価格
    double tp        = OrderTakeProfit();  // 利確価格
    double profit    = OrderProfit();      // 損益額
}

この前提を押さえた上で、各関数を詳しく見ていきましょう。

OrderOpenPrice() — エントリー価格を取得する

基本仕様

OrderOpenPrice() は、選択中の注文の約定価格（エントリー価格）を double 型で返します。

double OrderOpenPrice();

成行注文の場合は実際に約定した価格、指値・逆指値注文（未約定の待機注文）の場合は設定した注文価格が返ります。

使用例

if(OrderSelect(0, SELECT_BY_POS, MODE_TRADES))
{
    double entryPrice = OrderOpenPrice();
    Print("エントリー価格: ", entryPrice);
}

エントリー価格は、損益の計算やトレーリングストップのロジックなど、あらゆる場面で使う最も基本的な注文情報です。

OrderStopLoss() — 損切り価格を取得する

基本仕様

OrderStopLoss() は、選択中の注文に設定されているストップロス（損切り）価格を double 型で返します。

double OrderStopLoss();

ストップロスが設定されていない場合は 0 が返ります。この性質を利用して、「SLが未設定のポジションを検出する」といった処理が可能です（応用例で後述します）。

OrderTakeProfit() — 利確価格を取得する

基本仕様

OrderTakeProfit() は、選択中の注文に設定されているテイクプロフィット（利益確定）価格を double 型で返します。

double OrderTakeProfit();

OrderStopLoss() と同様に、テイクプロフィットが未設定の場合は 0 が返ります。

OrderCloseTime() — 決済時刻を取得する

基本仕様

OrderCloseTime() は、選択中の注文の決済時刻を datetime 型で返します。

datetime OrderCloseTime();

ここで重要なのが、まだ決済されていないポジション（保有中のポジション）の場合は 0 が返るという点です。この性質を使えば、「この注文はまだ保有中か、それとも決済済みか」を判定できます。

使用例

if(OrderSelect(i, SELECT_BY_POS, MODE_HISTORY))
{
    datetime closeTime = OrderCloseTime();
    if(closeTime > 0)
    {
        Print("決済時刻: ", TimeToString(closeTime, TIME_DATE | TIME_MINUTES));
    }
    else
    {
        Print("この注文はまだ未決済です");
    }
}

履歴からトレード結果を分析するEAや、日報を自動生成するスクリプトを作る際に活躍します。

OrderProfit() — 損益額を取得する

基本仕様

OrderProfit() は、選択中の注文の損益額（口座通貨建て）を double 型で返します。

double OrderProfit();

保有中のポジションなら含み損益、決済済みの注文なら確定損益が返ります。

重要な注意点：OrderProfit() が返す値にはスワップポイントと取引手数料は含まれません。スワップを含めた正確な損益を計算するには、OrderSwap() と OrderCommission() を加算する必要があります。

// スワップと手数料を含めた正確な損益
double totalProfit = OrderProfit() + OrderSwap() + OrderCommission();

実践サンプル：全ポジションの注文情報を一覧表示する

ここまで学んだ5つの関数を組み合わせて、保有中の全ポジション情報をエキスパートログに出力する実践的な関数を作ってみましょう。

void ShowAllOrderInfo()
{
    int totalOrders = OrdersTotal();
    Print("===== 保有ポジション一覧（全 ", totalOrders, " 件）=====");

    for(int i = totalOrders - 1; i >= 0; i--)
    {
        if(!OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
            continue;

        // 自分のEAの注文だけを対象にする
        if(OrderMagicNumber() != 12345)
            continue;

        // 待機注文を除外し、成行注文（ポジション）のみ対象にする
        if(OrderType() > OP_SELL)
            continue;

        string type = (OrderType() == OP_BUY) ? "BUY" : "SELL";
        double totalPL = OrderProfit() + OrderSwap() + OrderCommission();

        Print("チケット: ", OrderTicket(),
              " | 通貨: ", OrderSymbol(),
              " | ", type,
              " | ロット: ", OrderLots(),
              " | エントリー: ", DoubleToString(OrderOpenPrice(), Digits),
              " | SL: ", DoubleToString(OrderStopLoss(), Digits),
              " | TP: ", DoubleToString(OrderTakeProfit(), Digits),
              " | 損益: ", DoubleToString(totalPL, 2));
    }

    Print("==========================================");
}

ループを totalOrders - 1 から 0 に向かって逆順で回しているのがポイントです。これについては後述の注意点で詳しく説明します。

応用例：SL未設定ポジションに自動でSLを追加する

OrderStopLoss() が 0 を返す（＝SL未設定）ポジションを検出し、自動的にストップロスを設定する実用的なサンプルです。

void SetSLForUnprotectedPositions(int magicNumber, int slPips)
{
    for(int i = OrdersTotal() - 1; i >= 0; i--)
    {
        if(!OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
            continue;

        if(OrderMagicNumber() != magicNumber)
            continue;

        // SLが既に設定されている場合はスキップ
        if(OrderStopLoss() != 0)
            continue;

        double newSL = 0;
        double point = MarketInfo(OrderSymbol(), MODE_POINT);
        int    digits = (int)MarketInfo(OrderSymbol(), MODE_DIGITS);

        // 3桁/5桁業者対応
        if(digits == 3 || digits == 5)
            point *= 10;

        if(OrderType() == OP_BUY)
        {
            newSL = OrderOpenPrice() - slPips * point;
        }
        else if(OrderType() == OP_SELL)
        {
            newSL = OrderOpenPrice() + slPips * point;
        }
        else
        {
            continue; // 待機注文はスキップ
        }

        newSL = NormalizeDouble(newSL, digits);

        bool result = OrderModify(OrderTicket(), OrderOpenPrice(), newSL, OrderTakeProfit(), 0, clrYellow);

        if(result)
        {
            Print("SL設定成功 チケット:", OrderTicket(), " SL:", DoubleToString(newSL, digits));
        }
        else
        {
            Print("SL設定失敗 チケット:", OrderTicket(), " エラー:", GetLastError());
        }
    }
}

OrderStopLoss() != 0 で「SLが設定済みかどうか」を判定し、未設定のポジションにのみ OrderModify() でSLを追加しています。リスク管理を自動化する際にとても便利なパターンです。

3つの重要な注意点

1. OrderSelect() の呼び忘れに注意

繰り返しになりますが、すべての注文情報取得関数は OrderSelect() で注文を選択した後に呼ぶ必要があります。選択せずに使うと、前回選択した注文の情報が返ったり、不正な値が返ったりして、バグの原因になります。

2. ループは逆順（降順）で回す

注文一覧をループする際は、for(int i = OrdersTotal() - 1; i >= 0; i--) のように逆順で回すのがMQL4の定石です。

なぜなら、ループ中に注文が決済されるとインデックスがズレてしまうからです。昇順（0から）でループすると、途中の注文が消えた際にインデックスが詰まり、一部の注文がスキップされてしまいます。逆順で回せばこの問題を回避できます。

3. OrderProfit() にはスワップ・手数料が含まれない

OrderProfit() は純粋な為替差益のみを返します。スワップポイントや取引手数料は含まれません。正確なトータル損益を出すには、必ず以下のように計算してください。

double totalPL = OrderProfit() + OrderSwap() + OrderCommission();

特にスワップが大きい通貨ペアや、ECN口座のように手数料が発生する環境では、この差が無視できない金額になることがあります。

まとめ

今回解説した5つの関数を一覧表で整理します。

いずれの関数も、事前に OrderSelect() で注文を選択することが必須です。また、ループは逆順で回す、OrderProfit() にはスワップが含まれない、といったポイントを押さえておけば、安全で正確なEAを開発できます。

これらの関数をマスターすれば、ポジション管理・リスク管理・トレード分析など、EA開発の幅が大きく広がります。ぜひ実際のコードに組み込んで試してみてください！

投稿 【MQL4】注文情報を取得する関数を徹底解説！OrderOpenPrice・OrderStopLoss・OrderTakeProfit・OrderCloseTime・OrderProfit の使い方 は 自動売買を作ろう！ に最初に表示されました。