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でエントリーシグナルを作ろう は 自動売買を作ろう！ に最初に表示されました。

この記事では、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サンプル付き は 自動売買を作ろう！ に最初に表示されました。

朝日奈りさ

OrderType関数とは

「自動売買が買いポジションを決済するタイミングで、売りポジションを決済してしまった！」

そういう方は、買いポジションと売りポジションを、正しく判別できていない可能性があります。

買いと売りを正しく判別できていない場合、買いポジションを決済するつもりが、売りポジションを決済してしまったということが起こってしまいます。

そこで、OrderType関数を使って、ポジションの種類を判別し、ポジションを正しく決済させましょう！

OrderType関数は、ポジションの種類を返す関数です。

ポジションの種類を取得することで、買いと売りの判別ができるようになります。

判別ができることで、自動売買が決済するときに、ポジションを間違えずに決済することができます。

実行することで、ポジションが「買い」なのか「売り」なのかを判別することができるので、自動売買には必須の関数と言えるでしょう。

OrderType関数の書き方

OrderType関数の使い方は、基本的な関数と同じです。

関数をマスターしていない方はこちらの記事が参考になります。

【MQLプログラミング基礎】関数は難しい？関数の使い方を理解しよう！プログラム例あり

関数とは？ 「プログラムは、何度も同じことを書かないといけない」 と思っている方、ぜひ関数を使ってみてください。 関数とは、何度も繰り返すプログラムを、まとめた状態のものです。 事前に、まとまりを作っておくことで、同じプ

mql-programing.com

基本的な書き方

OrderType関数はとてもシンプルな関数です。

引数なしで実行できます。

ただし、OrderType関数を実行する前に、ポジションを選択しておく必要があります。

そのため、OrderSelect関数を実行してポジションを選択しておきましょう。

OrderType関数の基本的な書き方は以下の通りです。

int orderType = OrderType();

返り値は int型です。

OrderType関数を実行する前に、ポジションを選択しておく

OrderType関数は、事前にポジションを選択しないと実行することができません。

そのため、OrderTypeを実行する前に、ポジションを選択しておきましょう。

ポジションを選択するには、OrderSelect関数を使います。

必ず OrderSelect関数 → OrderType関数 の順にプログラムするので、以下のようなプログラムになります。

//保有ポジションを一つ選択
if(OrderSelect(0, SELECT_BY_POS, MODE_TRADES))
   {

   //選択したポジションが、買いポジションなのかチェック
   if(OrderType() == OP_BUY)
   {

      //ここにポジションを決済するプログラムを書く

   }
   }

このように、OrderType関数を実行する前に、ポジションを選択しておくようにしましょう。

ちなみに if文の条件式に「OP_BUY」と書いていますが、OP_BUYは買いポジションの定数です。

OrderType関数の返り値は、OP_BUYのような定数が入っているので、判別ができるというわけですね。

OrderSelect関数でポジションを選択し、OrderType関数で選択したポジションの種類を取得します。

ポジションの種類を取得することで、別のポジションを決済してしまうことを防ぐことが可能です。

OrderSelect関数は、こちらの記事が参考になります。

【MQL4関数】OrderSelect関数の使い方！保有ポジションの選択のやり方

目次 OrderSelect関数とはOrderSelect関数の書き方基本的な書き方返り値（戻り値）引数①index②select③poolOrderSelect関数の具体的な使い方（サンプルあり）まとめ OrderSe

mql-programing.com

返り値（戻り値）

OrderType関数の返り値は int型です。

返り値には、「買い」なのか「売り」なのかの定数が入っています。

定数は6種類あり、「買い指値」や「売り指値」なども判別することができます。

定数の種類はこちらの記事が参考になります。

【MQL4定数】注文種別の定数（OP_BUY ,OP_SELL）

目次 注文種別の定数注文種別の定数（OP_BUY ,OP_SELL）注文種別の定数の使い方 注文種別の定数 主にOrderSend関数の引数で使われる定数です。 定数を使わずに数値を入力しても、同様の結果が得られます。

mql-programing.com

基本的には、OP_BUY もしくは OP_SELL を使用することが多いです。

OP_BUY と OP_SELL だけ覚えてしまいましょう。

引数

なし

OrderType関数の具体的な使い方（サンプルあり）

先ほど、OrderSelect関数と組み合わせましたが、さらに他の関数とも組み合わせます。

上記の例では、ポジションを１つだけ選択して、ポジションの種類を取得していましたが、全てのポジションの種類を取得してみます。

全てのポジションの種類を取得するためには、for文を使って全てのポジションをチェックします。

そのとき、for文の条件式に保有ポジション数が必要となりますので、OrdersTotal関数と組み合わせて使ってみましょう。

例えば、以下のようなプログラムです。

//保有ポジションを一つずつチェックしていく
for( int i = OrdersTotal() - 1; i >= 0; i--)
   {

    //保有ポジションを一つ選択
    if( OrderSelect( i, SELECT_BY_POS, MODE_TRADES))
        {

            //選択したポジションが、買いポジションなのかチェック
            if( OrderType() == OP_BUY)
            {

            //ここにポジションを決済するプログラムを書く

            }
        }
   }

以下は、上記のロジックを組み込んだサンプルプログラムの全体像です。買いポジションだけを検出してログに出力する例になります。

//+------------------------------------------------------------------+
//| OrderType関数サンプル                                              |
//+------------------------------------------------------------------+
void OnTick()
{
   //保有ポジションを一つずつチェックしていく
   for( int i = OrdersTotal() - 1; i >= 0; i--)
   {
      //保有ポジションを一つ選択
      if( OrderSelect( i, SELECT_BY_POS, MODE_TRADES))
      {
         //選択したポジションが、買いポジションなのかチェック
         if( OrderType() == OP_BUY)
         {
            Print("買いポジションを検出しました。チケット番号: ", OrderTicket());

            //ここにポジションを決済するプログラムを書く
         }

         //選択したポジションが、売りポジションなのかチェック
         if( OrderType() == OP_SELL)
         {
            Print("売りポジションを検出しました。チケット番号: ", OrderTicket());

            //ここにポジションを決済するプログラムを書く
         }
      }
   }
}

このように書くことで、全てのポジションをチェックし、その中から買いポジションだけを選択することができます。

この書き方は、自動売買を作るときによく使う書き方なので、どこかにコピーしておくと良いでしょう。

OrdersTotal関数の使い方は、以下の記事が参考になります。

【MQL4関数】OrdersTotal関数の使い方！保有ポジション数の取得のやり方

目次 OrdersTotal関数とはOrdersTotal関数の使用方法と注意点まとめ OrdersTotal関数とは 自動売買でトレードするとき、保有ポジション数をチェックしたいですよね！ そのときに OrdersTo

mql-programing.com

まとめ

OrderType関数は、保有ポジションが買いなのか売りなのかを取得する関数です。

自動売買が決済するタイミングで、OrderType関数で買いと売りを判別しないと、間違ったポジションを決済する可能性があります。

使い方としては、OrderSelect関数で事前にポジションを選択する必要がありますので、注意しましょう。

また、上記で紹介したサンプルプログラムは、どの自動売買でも基本となる書き方なので、コピーしておくと良いでしょう。

「決済するポジションがおかしい」ということが無くなるように、自動売買を作っていきましょう！

【MQL4プログラミング】自動売買の作り方！FXで使えるテンプレートあり

目次 はじめにFX自動売買とはFX自動売買を作るための準備FX自動売買の作り方口座凍結の対策をするプログラムテンプレートを作る決済ロジックをプログラミングするプログラムテンプレートを作るエントリーロジックをプログラミング

mql-programing.com

MQL4リファレンス【全データ一覧】

/*! elementor - v3.6.5 - 27-04-2022 */.e-container.e-container--row .elementor-spacer-inner{width:var(--spacer-size)}.e-

mql-programing.com

投稿 【MQL4関数】OrderType関数の使い方！買いと売りを判別しよう は 自動売買を作ろう！ に最初に表示されました。

朝日奈りさ

OrderOpenPrice関数とは

OrderOpenPrice関数は、ポジションの価格を取得する関数です。

基本的に、この関数単体で使うことはなく、OrderClose関数などと組み合わせて使います。

いろんな場面で使う関数なので、覚えておくと良いでしょう。

OrderOpenPrice関数の書き方

OrderOpenPrice関数の使い方は、基本的な関数と同じです。

関数をマスターしていない方はこちらの記事が参考になります。

【MQLプログラミング基礎】関数は難しい？関数の使い方を理解しよう！プログラム例あり

関数とは？ 「プログラムは、何度も同じことを書かないといけない」 と思っている方、ぜひ関数を使ってみてください。 関数とは、何度も繰り返すプログラムを、まとめた状態のものです。 事前に、まとまりを作っておくことで、同じプ

mql-programing.com

基本的な書き方

OrderOpenPrice関数の基本的な書き方は以下の通りです。

double orderOpenPrice = OrderOpenPrice();

返り値はdouble型で引数はありません。

返り値を見ていきましょう。

返り値（戻り値）

OrderOpenPrice関数の返り値はdouble型です。

具体的には、エントリーしているポジションの価格が返ってきます。

例えば、「105.000円」でエントリーしているポジションの場合、「105.000」が返ってきます。

そのため、ポジションの価格情報が必要な場合、OrderOpenPrice関数を使うことで、簡単に取得することができます。

OrderOpenPrice関数の具体的な使い方

それでは、OrderOpenPrice関数の具体的な使い方を見ていきましょう。

OrderOpenPrice関数は、主に OrderClose関数や OrderModify関数を実行するときに使います。

具体的には以下のようなプログラムです。

//保有ポジションを一つ選択
    if(OrderSelect(10, SELECT_BY_POS, MODE_TRADES))
       {

        //ポジションのエントリー価格を取得
        double orderOpenPrice = OrderOpenPrice();

        //変更注文を出す
        bool orderModify = OrderModify(OrderTicket(), orderOpenPrice, OrderStopLoss(), 110.000, OrderExpiration(), clrRed);
       }
   }

まずは、OrderSelect関数でポジションを選択します。

その後、OrderOpenPrice関数で、ポジションのエントリー価格を取得します。

最後にOrderModify関数で、変更注文を出すというプログラムです。

このように変更注文（OrderModify関数）や決済注文（OrderClose関数）を実行するときに、とても便利な関数なので、覚えておくとスムーズにプログラミングできます。

OrderClose関数でも同じような使い方をしますので、サンプルプログラムを見てみてください。

まとめ

OrderOpenPriceはポジションのエントリー価格を取得する関数です。

実行する前に、ポジションを選択する必要があります。（OrderSelect関数）

また、OrderOpenPrice関数は単体で使うことはありません。

変更注文（OrderModify関数）や決済注文（OrderClose関数）を実行するときに、組み合わせて使われます。

サンプルプログラムを見ながら、少しづつ関数をマスターしていきましょう！

【MQL4プログラミング】自動売買の作り方！FXで使えるテンプレートあり

目次 はじめにFX自動売買とはFX自動売買を作るための準備FX自動売買の作り方口座凍結の対策をするプログラムテンプレートを作る決済ロジックをプログラミングするプログラムテンプレートを作るエントリーロジックをプログラミング

mql-programing.com

注文関係の記事一覧

朝日奈りさこちらは注文関係の記事一覧です。本サイトはサンプルプログラムを公開しております。「実際にプログラムをみたい！」という方にも参考になると思います。サンプルプログラムはこちらからあくまでサンプルプログラムです。ご利用は自己責任でお願い

mql-programing.com

投稿 【MQL4関数】OrderOpenPrice関数の使い方！エントリーした価格の取得方法 は 自動売買を作ろう！ に最初に表示されました。

朝日奈りさ

OrderClosePrice関数とは

ポジションを決済するときには、OrderClose関数を使います。

OrderClose関数を実行するためには、引数に「希望する決済価格」を設定する必要があります。

そこで OrderClosePrice関数を使いましょう。

OrderClosePrice関数とは、選択したポジションの決済価格を返す関数です。

決済価格を返すといっても難しいことはなく、現在の買値や売値の価格を返してくれます。

このように、ポジションを決済する関数（OrderClose関数）を実行するときに使う関数なので、覚えておくと良いでしょう。

OrderClosePrice関数の書き方

OrderClosePrice関数の使い方は、基本的な関数と同じです。

関数をマスターしていない方はこちらの記事が参考になります。

【MQLプログラミング基礎】関数は難しい？関数の使い方を理解しよう！プログラム例あり

関数とは？ 「プログラムは、何度も同じことを書かないといけない」 と思っている方、ぜひ関数を使ってみてください。 関数とは、何度も繰り返すプログラムを、まとめた状態のものです。 事前に、まとまりを作っておくことで、同じプ

mql-programing.com

基本的な書き方

OrderClosePrice関数の基本的な書き方は、以下の通りです。

double orderClosePrice = OrderClosePrice();

返り値は double型で、引数は必要ありません。

まずは返り値を見ていきましょう。

返り値（戻り値）

OrderClosePrice関数の返り値は double型です。

具体的には、自動売買を動かしている通貨ペアの価格が返ってきます。

例えばドル円の場合、現在の買値が「105.000円」の時、OrderClosePrice関数は「105.000」を返します。

ちなみに、売りポジションの場合は買値が返ってきて、買いポジションの場合は売値が返ってきます。

そのため、いちいちスプレッドを意識しなくても、決済価格を決めることができます。

OrderClosePrice関数の具体的な使い方

それでは、OrderClosePrice関数の具体的な使い方を見ていきましょう。

OrderClosePrice関数は、主に決済注文（OrderClose関数）を実行するときに使います。

具体的には以下の通りです。

//保有ポジションを一つ選択
if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
   {

      //決済価格を取得
      double orderClosePrice = OrderClosePrice();

      //ポジションを決済
      bool orderClose = OrderClose( OrderTicket(), OrderLots(), orderClosePrice, 10, clrNONE);

   }

初めに、OrderSelect関数でポジションを選択します。

その後 OrderClosePrice関数で、決済価格を取得します。

取得した決済価格を、OrderClose関数の引数として使います。

このように、決済注文（OrderClose関数）を出すときに便利な関数なので、覚えておくと良いでしょう。

OrderClosePrice関数の実用的なプログラム例

ここからは、OrderClosePrice関数を使った実用的なプログラム例を紹介します。実際のEA開発でよく使われるパターンなので、ぜひ参考にしてください。

例1：保有中の全ポジションを一括決済するEA

複数のポジションを保有しているときに、すべてのポジションを一括で決済する処理です。ループの中でOrderClosePriceを使って、各ポジションに合った決済価格を自動で取得しています。

//+------------------------------------------------------------------+
//| 全ポジション一括決済関数                                           |
//+------------------------------------------------------------------+
void CloseAllPositions()
{
   // ポジション数を取得（後ろからループすることで番号のズレを防ぐ）
   for(int i = OrdersTotal() - 1; i >= 0; i--)
   {
      // ポジションを選択
      if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
      {
         // 現在のチャートと同じ通貨ペアのポジションのみ対象
         if(OrderSymbol() == Symbol())
         {
            // OrderClosePriceで決済価格を自動取得（買い/売り問わず正しい価格が返る）
            double closePrice = OrderClosePrice();
            
            // ポジションを決済
            bool result = OrderClose(OrderTicket(), OrderLots(), closePrice, 10, clrRed);
            
            // 決済結果をログに出力
            if(result)
               Print("チケット番号 ", OrderTicket(), " を ", closePrice, " で決済しました");
            else
               Print("チケット番号 ", OrderTicket(), " の決済に失敗しました。エラー: ", GetLastError());
         }
      }
   }
}

ポイントは、ループを後ろから回す（デクリメント）ことです。前から回すと、決済時にポジション番号がズレてしまうので注意しましょう。

例2：指定pips以上の利益が出たら利確するEA

保有ポジションの含み益が一定のpips以上になったら、自動で利確する処理です。OrderClosePriceとOrderOpenPriceを組み合わせて、現在の損益pipsを計算しています。

//+------------------------------------------------------------------+
//| 利確pipsの設定                                                     |
//+------------------------------------------------------------------+
input double TakeProfitPips = 30.0;  // 利確するpips数

//+------------------------------------------------------------------+
//| OnTick関数：ティックごとに利確判定を行う                             |
//+------------------------------------------------------------------+
void OnTick()
{
   for(int i = OrdersTotal() - 1; i >= 0; i--)
   {
      if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
      {
         // 現在のチャートの通貨ペアのみ対象
         if(OrderSymbol() != Symbol()) continue;
         
         // 決済価格を取得（売りならAsk、買いならBidが自動で返る）
         double closePrice = OrderClosePrice();
         
         // エントリー価格を取得
         double openPrice = OrderOpenPrice();
         
         // 含み損益をpipsで計算
         double profitPips = 0;
         
         if(OrderType() == OP_BUY)
         {
            // 買いポジション：決済価格（Bid）- エントリー価格
            profitPips = (closePrice - openPrice) / Point / 10;
         }
         else if(OrderType() == OP_SELL)
         {
            // 売りポジション：エントリー価格 - 決済価格（Ask）
            profitPips = (openPrice - closePrice) / Point / 10;
         }
         
         // 設定したpips以上の利益が出たら決済
         if(profitPips >= TakeProfitPips)
         {
            bool result = OrderClose(OrderTicket(), OrderLots(), closePrice, 10, clrBlue);
            if(result)
               Print("利確決済！ 利益: ", profitPips, " pips");
         }
      }
   }
}

OrderClosePriceが買い・売りに応じて正しい決済価格を返してくれるので、損益計算と決済の両方で活用できます。

例3：合計損益がマイナスになったら全決済する損切りEA

複数ポジションの合計損失額が設定値を超えた場合に、全ポジションを一括で損切りする処理です。OrderClosePriceを使って各ポジションのリアルタイムな損益を確認しています。

//+------------------------------------------------------------------+
//| 最大許容損失額の設定（口座通貨ベース）                               |
//+------------------------------------------------------------------+
input double MaxLossAmount = -10000;  // これ以上の損失で全決済（例：-10,000円）

//+------------------------------------------------------------------+
//| OnTick関数：ティックごとに合計損益をチェック                         |
//+------------------------------------------------------------------+
void OnTick()
{
   double totalProfit = 0;
   
   // 全ポジションの合計損益を計算
   for(int i = 0; i < OrdersTotal(); i++)
   {
      if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
      {
         if(OrderSymbol() == Symbol())
         {
            // OrderProfitで現在の含み損益（口座通貨ベース）を取得
            totalProfit += OrderProfit() + OrderSwap() + OrderCommission();
         }
      }
   }
   
   // 合計損失が許容額を超えたら全決済
   if(totalProfit <= MaxLossAmount)
   {
      Print("合計損失が ", totalProfit, " に達したため、全ポジションを決済します");
      
      for(int i = OrdersTotal() - 1; i >= 0; i--)
      {
         if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
         {
            if(OrderSymbol() == Symbol())
            {
               // OrderClosePriceで正しい決済価格を取得
               double closePrice = OrderClosePrice();
               
               bool result = OrderClose(OrderTicket(), OrderLots(), closePrice, 10, clrRed);
               if(result)
                  Print("損切り決済完了：チケット ", OrderTicket());
               else
                  Print("決済失敗：チケット ", OrderTicket(), " エラー: ", GetLastError());
            }
         }
      }
   }
}

合計損益の計算にはOrderProfit関数を使い、決済の実行時にOrderClosePriceで正確な価格を取得しています。スワップや手数料も含めた判定にすることで、より実践的な損切りロジックになっています。

例4：トレーリングストップ（利益を追従する決済）EA

一定の利益が出たらストップロスを引き上げ、利益を追従しながら決済を狙うトレーリングストップの処理です。OrderClosePriceで現在の決済価格を取得し、ストップロスの更新判定に活用しています。

//+------------------------------------------------------------------+
//| トレーリングストップの設定                                          |
//+------------------------------------------------------------------+
input double TrailingStartPips = 20.0;  // トレーリング開始の利益pips
input double TrailingStopPips  = 10.0;  // ストップロスを何pips離すか

//+------------------------------------------------------------------+
//| OnTick関数：ティックごとにトレーリングストップを判定                  |
//+------------------------------------------------------------------+
void OnTick()
{
   // pipsをポイントに変換する倍率（5桁/3桁ブローカー対応）
   double pipPoint = Point * 10;
   
   for(int i = OrdersTotal() - 1; i >= 0; i--)
   {
      if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
      {
         // 現在のチャートの通貨ペアのみ対象
         if(OrderSymbol() != Symbol()) continue;
         
         // OrderClosePriceで現在の決済価格を取得
         double closePrice = OrderClosePrice();
         double openPrice  = OrderOpenPrice();
         double currentSL  = OrderStopLoss();
         
         // --- 買いポジションのトレーリングストップ ---
         if(OrderType() == OP_BUY)
         {
            // 現在の含み益をpipsで計算
            double profitPips = (closePrice - openPrice) / pipPoint;
            
            // トレーリング開始条件を満たしているか
            if(profitPips >= TrailingStartPips)
            {
               // 新しいストップロス価格を計算
               double newSL = closePrice - TrailingStopPips * pipPoint;
               
               // 現在のSLより高い場合のみ更新（SLを引き上げる）
               if(newSL > currentSL || currentSL == 0)
               {
                  bool result = OrderModify(OrderTicket(), openPrice, 
                                            NormalizeDouble(newSL, Digits), 
                                            OrderTakeProfit(), 0, clrGreen);
                  if(result)
                     Print("トレーリングSL更新：チケット ", OrderTicket(), 
                           " 新SL=", NormalizeDouble(newSL, Digits));
               }
            }
         }
         // --- 売りポジションのトレーリングストップ ---
         else if(OrderType() == OP_SELL)
         {
            // 現在の含み益をpipsで計算
            double profitPips = (openPrice - closePrice) / pipPoint;
            
            // トレーリング開始条件を満たしているか
            if(profitPips >= TrailingStartPips)
            {
               // 新しいストップロス価格を計算
               double newSL = closePrice + TrailingStopPips * pipPoint;
               
               // 現在のSLより低い場合のみ更新（SLを引き下げる）
               if(newSL < currentSL || currentSL == 0)
               {
                  bool result = OrderModify(OrderTicket(), openPrice, 
                                            NormalizeDouble(newSL, Digits), 
                                            OrderTakeProfit(), 0, clrGreen);
                  if(result)
                     Print("トレーリングSL更新：チケット ", OrderTicket(), 
                           " 新SL=", NormalizeDouble(newSL, Digits));
               }
            }
         }
      }
   }
}

OrderClosePriceで取得した決済価格を基準にして、「今決済したらいくらになるか」を把握しながらストップロスの位置を計算しています。買い・売りのどちらでも正しい価格が返るため、ロジックがシンプルに書けるのがメリットです。

例5：指定時刻に全ポジションを自動決済するEA

週末や経済指標発表前など、特定の時刻になったら保有中のポジションをすべて自動で決済する処理です。時間管理とOrderClosePriceを組み合わせた、実用的なリスク管理ロジックです。

//+------------------------------------------------------------------+
//| 自動決済時刻の設定                                                  |
//+------------------------------------------------------------------+
input int CloseHour   = 23;  // 決済する時（サーバー時間）
input int CloseMinute = 30;  // 決済する分

//+------------------------------------------------------------------+
//| OnTick関数：ティックごとに時刻を判定                                |
//+------------------------------------------------------------------+
void OnTick()
{
   // 現在のサーバー時間を取得
   int currentHour   = Hour();
   int currentMinute = Minute();
   
   // 指定時刻に達したかチェック
   if(currentHour == CloseHour && currentMinute == CloseMinute)
   {
      // 全ポジションを後ろからループして決済
      for(int i = OrdersTotal() - 1; i >= 0; i--)
      {
         if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
         {
            // 現在のチャートの通貨ペアのみ対象
            if(OrderSymbol() != Symbol()) continue;
            
            // マジックナンバーで自分のEAのポジションだけ決済する場合
            // if(OrderMagicNumber() != MagicNumber) continue;
            
            // OrderClosePriceで決済価格を取得
            double closePrice = OrderClosePrice();
            
            // 現在の損益情報をログに記録
            double profit = OrderProfit() + OrderSwap() + OrderCommission();
            Print("時刻決済：チケット ", OrderTicket(), 
                  " 損益=", profit, " 決済価格=", closePrice);
            
            // ポジションを決済
            bool result = OrderClose(OrderTicket(), OrderLots(), closePrice, 15, clrYellow);
            
            if(!result)
            {
               // 決済失敗時はエラーコードを記録して再試行の目安にする
               int err = GetLastError();
               Print("時刻決済失敗：チケット ", OrderTicket(), 
                     " エラーコード=", err);
            }
         }
      }
   }
}

週末持ち越しを避けたい場合は「金曜の23:30」などに設定すると便利です。マジックナンバーによるフィルタリングのコメント部分を有効にすれば、自分のEAが出したポジションだけを対象にすることもできます。

例6：ポジション情報をチャート上に表示するインジケーター

保有中のポジションの決済価格・含み損益をチャート上にリアルタイム表示するインジケーターです。OrderClosePriceを使って各ポジションの現在の決済価格を取得し、一覧として視覚的に確認できます。

//+------------------------------------------------------------------+
//| ポジション情報表示インジケーター                                     |
//+------------------------------------------------------------------+
#property indicator_chart_window

//+------------------------------------------------------------------+
//| 初期化処理                                                         |
//+------------------------------------------------------------------+
int OnInit()
{
   return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| 終了処理：オブジェクトを削除                                        |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
   // 表示したオブジェクトをすべて削除
   ObjectsDeleteAll(0, "PosInfo_");
}

//+------------------------------------------------------------------+
//| メイン処理：ティックごとにポジション情報を更新                       |
//+------------------------------------------------------------------+
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[])
{
   // 前回の表示をクリア
   ObjectsDeleteAll(0, "PosInfo_");
   
   int displayLine = 0;  // 表示行カウンター
   
   for(int i = 0; i < OrdersTotal(); i++)
   {
      if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
      {
         // 現在のチャートの通貨ペアのみ対象
         if(OrderSymbol() != Symbol()) continue;
         
         // OrderClosePriceで現在の決済価格を取得
         double closePrice = OrderClosePrice();
         double openPrice  = OrderOpenPrice();
         double profit     = OrderProfit() + OrderSwap() + OrderCommission();
         
         // ポジション種別の文字列を作成
         string typeStr = (OrderType() == OP_BUY) ? "BUY" : "SELL";
         
         // 含み損益のpipsを計算
         double pipPoint = Point * 10;
         double pips = 0;
         if(OrderType() == OP_BUY)
            pips = (closePrice - openPrice) / pipPoint;
         else
            pips = (openPrice - closePrice) / pipPoint;
         
         // 表示する文字列を組み立て
         string info = StringConcatenate(
            "#", OrderTicket(), " ", typeStr, 
            " | Lots:", DoubleToStr(OrderLots(), 2),
            " | Open:", DoubleToStr(openPrice, Digits),
            " | Close:", DoubleToStr(closePrice, Digits),
            " | ", DoubleToStr(pips, 1), "pips",
            " | ", DoubleToStr(profit, 0), "円");
         
         // オブジェクト名を作成
         string objName = "PosInfo_" + IntegerToString(displayLine);
         
         // チャート左上にテキストラベルとして表示
         ObjectCreate(0, objName, OBJ_LABEL, 0, 0, 0);
         ObjectSetInteger(0, objName, OBJPROP_CORNER, CORNER_LEFT_UPPER);
         ObjectSetInteger(0, objName, OBJPROP_XDISTANCE, 10);
         ObjectSetInteger(0, objName, OBJPROP_YDISTANCE, 20 + displayLine * 20);
         ObjectSetString(0, objName, OBJPROP_TEXT, info);
         ObjectSetInteger(0, objName, OBJPROP_FONTSIZE, 10);
         
         // 損益に応じて文字色を変更（プラスなら青、マイナスなら赤）
         color textColor = (profit >= 0) ? clrDodgerBlue : clrRed;
         ObjectSetInteger(0, objName, OBJPROP_COLOR, textColor);
         
         displayLine++;
      }
   }
   
   return(rates_total);
}

OrderClosePriceで取得した決済価格をそのままチャート上に表示しているので、「今決済したらいくらで約定するか」をリアルタイムで確認できます。損益がプラスなら青、マイナスなら赤で表示されるため、視覚的にもわかりやすいインジケーターです。

まとめ

OrderClosePrice関数は、選択したポジションの決済価格を返す関数です。買いポジションの場合は売値（Bid）、売りポジションの場合は買値（Ask）が自動的に返されるため、スプレッドを意識せずに正しい決済価格を取得できます。

主にOrderClose関数と組み合わせてポジションの決済処理に使いますが、含み損益の計算やトレーリングストップの判定など、幅広い場面で活用できる便利な関数です。

投稿 【MQL4関数】OrderClosePrice関数の使い方！決済価格の取得方法 は 自動売買を作ろう！ に最初に表示されました。

朝日奈りさ

OrderModify関数とは

ポジションの損切や利確の価格を変更したいときはありませんか？

損切りや利確はエントリーするとき（OrderSend関数）に設定するのが一般的ですが、エントリー後でも変更することができます。

自動売買でポジションの変更注文を出すには、OrderModify関数を使います。

OrderModify関数は、ポジションの変更注文を出す関数です。

変更できるポジションの種類は以下の通りです。

• エントリー後のポジション
• 予約ポジション（指値・逆指値）

つまりどちらかのポジションであれば、変更注文を出すことができます。

しかし変更できる内容には制限があります。

もちろんロット数や取得価格を変更することはできません。

変更できる内容は以下の４つです。

• 予約ポジションの注文価格
• 損切り価格
• 利確価格
• 予約ポジションの有効期限

特に、損切り価格や利確価格を変更するときに、OrderModify関数がよく使われます。

少し上級者向けの関数ですが、OrderModify関数の使い所は多いので、覚えてしまいましょう。

OrderModify関数の書き方

OrderModify関数の使い方は、基本的な関数と同じです。

関数をマスターしていない方はこちらの記事が参考になります。

【MQLプログラミング基礎】関数は難しい？関数の使い方を理解しよう！プログラム例あり

関数とは？ 「プログラムは、何度も同じことを書かないといけない」 と思っている方、ぜひ関数を使ってみてください。 関数とは、何度も繰り返すプログラムを、まとめた状態のものです。 事前に、まとまりを作っておくことで、同じプ

mql-programing.com

基本的な書き方

OrderModify関数の基本的な書き方は以下の通りです。

簡単のために引数を省略しています。

bool orderModify = OrderModify( ①, ②, ③, ④, ⑤, ⑥);

OrderModify関数の返り値は bool型で、引数は６つあります。

まずは返り値から見ていきましょう。

返り値（戻り値）

OrderModify関数の返り値は bool型です。

「true」や「false」という値が返ってきます。

数値にすると「１」や「０」です。

true や false が返ってくる条件は以下の通りです。

• true：変更注文が正常に完了したとき
• false：変更注文が失敗したとき

もし、false が返ってきた場合、変更注文が失敗しているため、再度 OrderModify関数を実行する必要があります。

ですが、注文の９９％は正常に完了するため、そこまで気にしなくても大丈夫です。

もし変更注文が失敗していた場合は、手動で変更しましょう。

引数

OrderModify関数の引数は６つあります。

引数が多いので、一つ一つゆっくり見ていきましょう。

まずは一覧で確認します。

それぞれ詳しく解説しますので、一緒に OrderModify関数を作っていきましょう。

① ticket

ticket には変更したいポジションのチケット番号を入力します。

ポジションのチケット番号を直接入力しても良いですが、OrderTicket関数という便利な関数があるので、それを使うと良いでしょう。

OrderTicket関数を実行する前に、OrderSelect関数でポジションを選択しておく必要がありますので、注意してください。

bool orderModify = OrderModify(OrderTicket(), ②, ③, ④, ⑤, ⑥)

② price

price には変更後の取得価格を入力します。

こちらは予約ポジション（指値注文、逆指値注文）の場合のみ変更可能です。

エントリー後のポジションの場合は、取得価格を変更できないので注意しましょう。

エントリー後のポジションを指定する場合は、エントリーしている価格を入力します。

ここでも便利な関数として、OrderOpenPrice関数というものがありますので、利用してみてください。

bool orderModify = OrderModify(OrderTicket(), OrderOpenPrice(), ③, ④, ⑤, ⑥)

③ stoploss

stoploss には、変更後の損切り価格を入力します。

ここで注意していただきたいのは、stoplossの価格は、現在の価格より下に設定する事です。

もし現在の価格より、有利な価格を入力すると、注文が通りません。

エラーにはなりませんが、「変更注文を出したのに、処理されてない！」ということになる可能性もあるので、stoplossの価格設定には注意しましょう。

stoplossで設定できるのは以下の３通りです。

• 0
• 損切り価格
• OrderStopLoss関数

0の場合は、損切りなしに設定します。

損切り価格を入力した場合は、その価格に損切りが入ります。

OrderStopLoss関数を利用した場合は、変更前の損切り価格が設定されます。

もし損切り価格を変更せずに、他の項目を変更したい場合は、OrderStopLoss関数を使うと良いでしょう。

bool orderModify = OrderModify(OrderTicket(), OrderOpenPrice(), OrderStopLoss(), ④, ⑤, ⑥)

④ takeprofit

takeprofitには変更後の利確価格を入力します。

stoplossの入力と同じように、現在の価格より上でなければ注文が通りません。

takeprofitで設定できるのは以下の３通りです。

• 0
• 利確価格
• OrderTakeProfit関数

0の場合は、利確なしに設定します。

利確価格を入力した場合は、その価格に利確が入ります。

OrderTakeProfit関数を利用した場合は、変更前の利確価格が設定されます。

他の項目を変更する場合は、OrderTakeProfit関数を利用すると良いでしょう。

ここでは、利確価格を変更するため、以下のように入力します。

bool orderModify = OrderModify(OrderTicket(), OrderOpenPrice(), OrderStopLoss(), 110.000, ⑤, ⑥)

⑤ expiration

expirationには、ポジションの有効期限を入力します。

この引数はほとんど使わないので、読み飛ばしていただいても大丈夫です。

expirationは予約ポジションのみ設定が可能です。

エントリー後のポジションには使えませんので、ご注意ください。

expirationはdatetime型の変数なので、datetime型の形式に合わせないとエラーが出ます。

例えば、以下のような形式です。2021年9月22日00時00分00秒まで有効という設定です。

datetime expiration = D'2021.09.22 00:00:00';

このように少し厄介な引数なので、基本的に OrderExpiration関数を使用すればOKです。

OrderExpiration関数は、変更前の有効期限を返す関数です。

そのため、有効期限を変更しない場合は、この関数を使用すれば問題ありません。

bool orderModify = OrderModify(OrderTicket(), OrderOpenPrice(), OrderStopLoss(), 110.000, OrderExpiration(), ⑥)

⑥ arrow_color

最後にarrow_colorの設定です。

こちらは、変更注文を出した位置に印がつくのですが、その色を設定します。

色をつけなくても良い場合は、「０」または、clrNONEと入力してください。

透明になりますので、チャート分析の邪魔にならないかと思います。

もし色をつけたい場合は、「clr○○」という特殊な変数がありますので、そちらを利用すると良いでしょう。

私は、clrRedが好きなので、clrRedを設定しています。

bool orderModify = OrderModify(OrderTicket(), OrderOpenPrice(), OrderStopLoss(), 110.000, OrderExpiration(), clrRed)

OrderModify関数の引数のまとめ

ここまでOrderModify関数の引数を、ざっと見てきました。

stoplossやtakeprofitの価格設定には気をつけるようにしてください。

また、両方同時に変更することもできるので、両方変更したい場合は、価格を入力すると変更できます。

変更する前の情報を取得するには、以下の関数が便利です。

• OrderStopLoss関数
• OrderTakeProfit関数
• OrderExpiration関数

以下のプログラムはOrderModify関数の完成例です。

bool orderModify = OrderModify(OrderTicket(), OrderOpenPrice(), OrderStopLoss(), 110.000, OrderExpiration(), clrRed)

これで基本的な書き方はマスターできたと思いますので、具体的な使い方も見ていきましょう。

OrderModify関数の実用的なプログラム例

ここからは、実際のEAで使える実用的なプログラム例を紹介していきます。

OrderModify関数の基本的な書き方がわかったら、ぜひこれらの応用例も参考にしてみてください。

例１：トレーリングストップEA

最も実用的な使い方がトレーリングストップです。価格が有利な方向に動いたら、損切りラインを自動で引き上げ（引き下げ）て利益を確保する手法です。

以下のEAは、保有中の全ポジションに対してトレーリングストップを適用します。

//+------------------------------------------------------------------+
//| トレーリングストップEA                                              |
//| 価格が有利に動いたら損切りラインを自動で追従させる                      |
//+------------------------------------------------------------------+
input int TrailingStopPips = 30;  // トレーリングストップ幅（pips）
input int TrailingStartPips = 20; // トレーリング開始条件（pips利益が出てから）

void OnTick()
{
   // ポイント値を取得（5桁ブローカー対応）
   double pip = Point;
   if(Digits == 3 || Digits == 5)
      pip = Point * 10;

   // 保有中の全ポジションをループ
   for(int i = OrdersTotal() - 1; i >= 0; i--)
   {
      // ポジションを選択
      if(!OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
         continue;

      // 自分のEAの通貨ペアが一致するか確認
      if(OrderSymbol() != Symbol())
         continue;

      // 買いポジションのトレーリングストップ
      if(OrderType() == OP_BUY)
      {
         // 現在の利益がトレーリング開始条件を超えているか
         double buyProfit = Bid - OrderOpenPrice();
         if(buyProfit >= TrailingStartPips * pip)
         {
            // 新しい損切り価格を計算
            double newSL = Bid - TrailingStopPips * pip;
            // 現在のSLより有利（高い）場合のみ変更
            if(newSL > OrderStopLoss() || OrderStopLoss() == 0)
            {
               bool result = OrderModify(
                  OrderTicket(),       // チケット番号
                  OrderOpenPrice(),    // 取得価格はそのまま
                  NormalizeDouble(newSL, Digits), // 新しい損切り価格
                  OrderTakeProfit(),   // 利確はそのまま
                  OrderExpiration(),   // 有効期限はそのまま
                  clrBlue             // 矢印の色（青）
               );
               if(result)
                  Print("買いトレーリングストップ更新: SL=", newSL);
               else
                  Print("トレーリングストップ更新失敗: エラー=", GetLastError());
            }
         }
      }

      // 売りポジションのトレーリングストップ
      if(OrderType() == OP_SELL)
      {
         // 現在の利益がトレーリング開始条件を超えているか
         double sellProfit = OrderOpenPrice() - Ask;
         if(sellProfit >= TrailingStartPips * pip)
         {
            // 新しい損切り価格を計算
            double newSL = Ask + TrailingStopPips * pip;
            // 現在のSLより有利（低い）場合のみ変更
            if(newSL < OrderStopLoss() || OrderStopLoss() == 0)
            {
               bool result = OrderModify(
                  OrderTicket(),       // チケット番号
                  OrderOpenPrice(),    // 取得価格はそのまま
                  NormalizeDouble(newSL, Digits), // 新しい損切り価格
                  OrderTakeProfit(),   // 利確はそのまま
                  OrderExpiration(),   // 有効期限はそのまま
                  clrRed              // 矢印の色（赤）
               );
               if(result)
                  Print("売りトレーリングストップ更新: SL=", newSL);
               else
                  Print("トレーリングストップ更新失敗: エラー=", GetLastError());
            }
         }
      }
   }
}

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

• TrailingStartPipsで指定したpips分の利益が出てからトレーリングを開始します
• TrailingStopPipsで指定したpips幅で損切りラインを追従させます
• 現在の損切りラインより有利な場合のみ変更するので、損切りが不利な方向に動くことはありません
• NormalizeDouble関数で価格を正規化しているため、小数点エラーを防げます

例２：建値ストップ（ブレイクイーブン）

一定の利益が出たら、損切りラインをエントリー価格に移動させる建値ストップも非常に人気があります。

これにより、最低でも損失ゼロ（スプレッド分を除く）を保証できます。

//+------------------------------------------------------------------+
//| 建値ストップ（ブレイクイーブン）の例                                  |
//| 一定利益が出たらSLをエントリー価格に移動                              |
//+------------------------------------------------------------------+
input int BreakevenPips = 20; // 建値ストップ発動条件（pips）

void SetBreakeven()
{
   double pip = Point;
   if(Digits == 3 || Digits == 5)
      pip = Point * 10;

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

      if(OrderSymbol() != Symbol())
         continue;

      // 買いポジション
      if(OrderType() == OP_BUY)
      {
         // 条件を満たし、かつSLがまだエントリー価格以下の場合
         if(Bid - OrderOpenPrice() >= BreakevenPips * pip)
         {
            if(OrderStopLoss() < OrderOpenPrice() || OrderStopLoss() == 0)
            {
               bool result = OrderModify(
                  OrderTicket(),
                  OrderOpenPrice(),
                  OrderOpenPrice(),    // SLをエントリー価格に設定
                  OrderTakeProfit(),
                  OrderExpiration(),
                  clrGreen
               );
               if(result)
                  Print("建値ストップ設定完了: チケット=", OrderTicket());
            }
         }
      }

      // 売りポジション
      if(OrderType() == OP_SELL)
      {
         if(OrderOpenPrice() - Ask >= BreakevenPips * pip)
         {
            if(OrderStopLoss() > OrderOpenPrice() || OrderStopLoss() == 0)
            {
               bool result = OrderModify(
                  OrderTicket(),
                  OrderOpenPrice(),
                  OrderOpenPrice(),    // SLをエントリー価格に設定
                  OrderTakeProfit(),
                  OrderExpiration(),
                  clrGreen
               );
               if(result)
                  Print("建値ストップ設定完了: チケット=", OrderTicket());
            }
         }
      }
   }
}

例３：利確価格を段階的に変更する

利確価格を状況に応じて変更したい場合の例です。

例えば、エントリー後に相場の勢いが強い場合、利確ラインをさらに遠くに設定し直すことで、利益の最大化を狙えます。

//+------------------------------------------------------------------+
//| 利確価格を段階的に変更する例                                        |
//+------------------------------------------------------------------+
input int InitialTPPips = 50;   // 初期利確幅（pips）
input int ExtendedTPPips = 100; // 拡張利確幅（pips）
input int ExtendTriggerPips = 30; // 拡張トリガー（pips利益）

void AdjustTakeProfit()
{
   double pip = Point;
   if(Digits == 3 || Digits == 5)
      pip = Point * 10;

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

      if(OrderSymbol() != Symbol())
         continue;

      // 買いポジションの利確拡張
      if(OrderType() == OP_BUY)
      {
         double currentProfit = Bid - OrderOpenPrice();
         double initialTP = OrderOpenPrice() + InitialTPPips * pip;
         double extendedTP = OrderOpenPrice() + ExtendedTPPips * pip;

         // トリガー条件を満たし、TPがまだ初期値の場合
         if(currentProfit >= ExtendTriggerPips * pip)
         {
            if(NormalizeDouble(OrderTakeProfit(), Digits) == NormalizeDouble(initialTP, Digits))
            {
               bool result = OrderModify(
                  OrderTicket(),
                  OrderOpenPrice(),
                  OrderStopLoss(),
                  NormalizeDouble(extendedTP, Digits), // 利確を拡張
                  OrderExpiration(),
                  clrYellow
               );
               if(result)
                  Print("利確拡張完了: 新TP=", extendedTP);
            }
         }
      }

      // 売りポジションの利確拡張
      if(OrderType() == OP_SELL)
      {
         double currentProfit = OrderOpenPrice() - Ask;
         double initialTP = OrderOpenPrice() - InitialTPPips * pip;
         double extendedTP = OrderOpenPrice() - ExtendedTPPips * pip;

         if(currentProfit >= ExtendTriggerPips * pip)
         {
            if(NormalizeDouble(OrderTakeProfit(), Digits) == NormalizeDouble(initialTP, Digits))
            {
               bool result = OrderModify(
                  OrderTicket(),
                  OrderOpenPrice(),
                  OrderStopLoss(),
                  NormalizeDouble(extendedTP, Digits), // 利確を拡張
                  OrderExpiration(),
                  clrYellow
               );
               if(result)
                  Print("利確拡張完了: 新TP=", extendedTP);
            }
         }
      }
   }
}

OrderModify関数を使うときの注意点

最後に、OrderModify関数を使うときの注意点をまとめます。

注意点１：OrderSelect関数を事前に実行する

OrderModify関数を使う前に、必ずOrderSelect関数でポジションを選択しておきましょう。

OrderTicket関数やOrderOpenPrice関数などは、OrderSelect関数で選択されたポジションの情報を返すため、選択を忘れるとエラーの原因になります。

注意点２：NormalizeDouble関数で価格を正規化する

価格を計算で求める場合は、NormalizeDouble関数で小数点以下の桁数を揃えましょう。

桁数が合わないと注文が通らないことがあります。

// 正しい例
double newSL = NormalizeDouble(Bid - 30 * Point, Digits);

// 間違いやすい例（正規化なし）
double newSL = Bid - 30 * Point; // 桁数がずれる可能性あり

注意点３：変更内容がない場合はエラーになる

OrderModify関数は、何も変更がない状態で実行するとエラー（エラーコード1）が発生します。

損切り価格が同じなのに変更注文を出すと失敗するため、変更前と変更後の値が異なることを確認してから実行しましょう。

注意点４：ストップレベルに注意する

ブローカーによっては、現在価格から一定距離以内にSL/TPを設定できないストップレベルが設けられています。

ストップレベルはMarketInfo関数で取得できます。

// ストップレベルの取得
double stopLevel = MarketInfo(Symbol(), MODE_STOPLEVEL) * Point;
Print("ストップレベル: ", stopLevel);

まとめ

今回は、OrderModify関数の使い方を解説しました。

OrderModify関数を使えば、エントリー後のポジションの損切りや利確を自動で変更できます。

特にトレーリングストップや建値ストップは実際のEAでも非常によく使われるテクニックです。

大切なポイントをおさらいしましょう。

• OrderModify関数の返り値はbool型（true：成功、false：失敗）
• 引数は６つ（チケット番号、価格、損切り、利確、有効期限、矢印の色）
• 変更しない項目には、OrderStopLoss関数やOrderTakeProfit関数で現在の値を設定する
• 事前にOrderSelect関数でポジションを選択しておくことを忘れずに
• 価格はNormalizeDouble関数で正規化する

OrderModify関数をマスターすれば、より柔軟で高度な自動売買プログラムを作成できるようになります。

ぜひ今回の記事を参考に、OrderModify関数を使ったEA開発に挑戦してみてください。

投稿 【MQL4関数】OrderModify 関数の使い方！ポジションの変更注文の出し方 は 自動売買を作ろう！ に最初に表示されました。

朝日奈りさ

OrderLots関数とは

OrderLots関数とは、選択したポジションのロット数を取得する関数です。

OrderLots関数を実行する前に、ポジションを選択する必要があるので、OrderSelect関数と組み合わせて使います。

使う場面は限られていますが、ポジションを決済するときに使う重要な関数なので、覚えておきましょう。

OrderLots関数の書き方

OrderLots関数の使い方は、基本的な関数と同じです。

関数をマスターしていない方はこちらの記事が参考になります。

【MQLプログラミング基礎】関数は難しい？関数の使い方を理解しよう！プログラム例あり

関数とは？ 「プログラムは、何度も同じことを書かないといけない」 と思っている方、ぜひ関数を使ってみてください。 関数とは、何度も繰り返すプログラムを、まとめた状態のものです。 事前に、まとまりを作っておくことで、同じプ

mql-programing.com

基本的な書き方

OrderLots関数の基本的な書き方は以下の通りです。

double lots = OrderLots();

このように返り値は double型で、引数は必要ありません。

まずは返り値から見ていきましょう。

返り値（戻り値）

OrderLots関数の返り値は double型です。

選択したポジションのロット数が返ってきます。

注意することは１つです。

ロット数は、全てのポジションの合計値ではなく、１つのポジションのロット数が返ってきます。

そのため、全てのポジションの合計値を使いたい場合は、for文で OrderLots関数の返り血を合計すると良いでしょう。

OrderLots関数の具体的な使い方

それでは、OrderLots関数の具体的な使い方を見ていきましょう。

OrderLots関数は、主に決済注文（OrderClose関数）を出すときに使用します。

具体的には以下のようなプログラムを使います。

//保有ポジションを一つ選択
if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
   {

      //ロット数を取得
      double lots = OrderLots();

      //ポジションを決済
      bool orderClose = OrderClose( OrderTicket(), lots, OrderClosePrice(), 10, clrNONE);

   }

初めに、OrderSelect関数で決済したいポジションを選択します。

その後にOrderLots関数で、ポジションのロット数を取得し、OrderClose関数の引数に書いています。

このように、決済注文（OrderClose関数）を出すときに便利な関数なので、覚えておくと良いでしょう。

OrderLots関数の実用的なプログラム例

ここからは、OrderLots関数を使った実用的なプログラム例を紹介します。実際のEA開発でよく使うパターンばかりなので、ぜひ参考にしてください。

例1：全ポジションの合計ロット数を計算する

ナンピンEAやマーチンゲールEAでは、保有中の全ポジションの合計ロット数を把握することが重要です。以下のプログラムでは、現在の通貨ペアの合計ロット数を計算しています。

//+------------------------------------------------------------------+
//| 現在の通貨ペアの合計ロット数を計算する関数                         |
//+------------------------------------------------------------------+
double GetTotalLots(int magicNumber)
  {
   double totalLots = 0.0; // 合計ロット数を格納する変数

   // 全ポジションをループで確認
   for(int i = OrdersTotal() - 1; i >= 0; i--)
     {
      // ポジションを選択
      if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
        {
         // 通貨ペアとマジックナンバーが一致するか確認
         if(OrderSymbol() == Symbol() && OrderMagicNumber() == magicNumber)
           {
            // OrderLots関数でロット数を取得し、合計に加算
            totalLots += OrderLots();
           }
        }
     }

   return totalLots; // 合計ロット数を返す
  }

//+------------------------------------------------------------------+
//| 使用例：OnTick内で合計ロット数を確認                              |
//+------------------------------------------------------------------+
void OnTick()
  {
   int myMagic = 12345;

   // 合計ロット数を取得
   double total = GetTotalLots(myMagic);

   // 合計ロット数が上限を超えていたら新規注文を出さない
   double maxLots = 1.0; // 最大合計ロット数
   if(total >= maxLots)
     {
      Comment("合計ロット数が上限に達しています: ", DoubleToString(total, 2), " lots");
      return; // 新規注文を行わない
     }

   // ここに通常のエントリーロジックを記述
   Comment("現在の合計ロット数: ", DoubleToString(total, 2), " lots");
  }

このように、for文でOrderLots関数の戻り値を合計することで、リスク管理に役立てることができます。

例2：全ポジションを一括決済するEA

複数のポジションをまとめて決済する場面は非常に多いです。以下のプログラムでは、自分のEAが出した全ポジションをOrderLots関数で取得したロット数を使って一括決済しています。

#define MAGIC_NUMBER 12345 // マジックナンバーの定義

//+------------------------------------------------------------------+
//| 全ポジションを一括決済する関数                                     |
//+------------------------------------------------------------------+
void CloseAllPositions()
  {
   // ポジション数が0になるまで繰り返す（逆順ループ）
   for(int i = OrdersTotal() - 1; i >= 0; i--)
     {
      // ポジションを選択できるか確認
      if(!OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
         continue;

      // 自分のEAのポジションかつ、現在の通貨ペアか確認
      if(OrderSymbol() != Symbol() || OrderMagicNumber() != MAGIC_NUMBER)
         continue;

      // OrderLots関数でロット数を取得
      double lots = OrderLots();

      // 注文タイプに応じて決済価格を設定
      double closePrice = 0;
      if(OrderType() == OP_BUY)
         closePrice = Bid;  // 買いポジションはBidで決済
      else if(OrderType() == OP_SELL)
         closePrice = Ask;  // 売りポジションはAskで決済
      else
         continue; // 指値・逆指値注文はスキップ

      // ポジションを決済（取得したロット数を使用）
      bool result = OrderClose(OrderTicket(), lots, closePrice, 10, clrRed);

      // 決済結果をログに出力
      if(result)
         Print("決済成功 チケット:", OrderTicket(), " ロット:", DoubleToString(lots, 2));
      else
         Print("決済失敗 チケット:", OrderTicket(), " エラー:", GetLastError());
     }
  }

//+------------------------------------------------------------------+
//| OnTick - 利益が一定額を超えたら全決済する例                       |
//+------------------------------------------------------------------+
void OnTick()
  {
   double totalProfit = 0.0;

   // 全ポジションの損益を合計
   for(int i = OrdersTotal() - 1; i >= 0; i--)
     {
      if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
        {
         if(OrderSymbol() == Symbol() && OrderMagicNumber() == MAGIC_NUMBER)
           {
            totalProfit += OrderProfit() + OrderSwap() + OrderCommission();
           }
        }
     }

   // 利益が10,000円を超えたら全決済
   if(totalProfit >= 10000)
     {
      Print("利益目標達成！全ポジション決済開始 利益:", DoubleToString(totalProfit, 0), "円");
      CloseAllPositions();
     }

   Comment("現在の合計損益: ", DoubleToString(totalProfit, 0), "円");
  }

一括決済は、利益確定や損切りの自動化で非常によく使うパターンです。OrderLots関数でロット数を正しく取得できないと決済が失敗するので、必ずセットで覚えておきましょう。

例3：ポジションの半分だけ部分決済するEA

利益が出たポジションの半分だけを決済して利益を確保し、残りのポジションで利益を伸ばす「部分決済」は、裁量トレーダーにも人気のテクニックです。OrderLots関数で取得したロット数を半分にすることで実現できます。

#define MAGIC_NUMBER 12345 // マジックナンバー
input double PartialCloseProfit = 50.0; // 部分決済を行う利益pips

//+------------------------------------------------------------------+
//| ポジションの半分を部分決済する関数                                 |
//+------------------------------------------------------------------+
bool PartialClose(int ticket)
  {
   // チケット番号でポジションを選択
   if(!OrderSelect(ticket, SELECT_BY_TICKET))
     {
      Print("ポジション選択失敗 チケット:", ticket);
      return false;
     }

   // OrderLots関数で現在のロット数を取得
   double currentLots = OrderLots();

   // 半分のロット数を計算（最小ロット数以上になるよう調整）
   double halfLots = NormalizeDouble(currentLots / 2.0, 2);
   double minLot   = MarketInfo(Symbol(), MODE_MINLOT); // 最小ロット数を取得

   // 半分のロット数が最小ロット未満なら部分決済できない
   if(halfLots < minLot)
     {
      Print("ロット数が小さすぎるため部分決済できません。現在:", 
            DoubleToString(currentLots, 2), " 半分:", DoubleToString(halfLots, 2));
      return false;
     }

   // 決済価格を注文タイプに応じて設定
   double closePrice = 0;
   if(OrderType() == OP_BUY)
      closePrice = MarketInfo(Symbol(), MODE_BID);
   else if(OrderType() == OP_SELL)
      closePrice = MarketInfo(Symbol(), MODE_ASK);
   else
      return false;

   // 半分のロット数だけ決済を実行
   bool result = OrderClose(ticket, halfLots, closePrice, 10, clrBlue);

   if(result)
      Print("部分決済成功 チケット:", ticket, 
            " 決済ロット:", DoubleToString(halfLots, 2),
            " 残りロット:", DoubleToString(currentLots - halfLots, 2));
   else
      Print("部分決済失敗 チケット:", ticket, " エラー:", GetLastError());

   return result;
  }

//+------------------------------------------------------------------+
//| OnTick - 利益が一定pipsを超えたら半分決済                         |
//+------------------------------------------------------------------+
void OnTick()
  {
   for(int i = OrdersTotal() - 1; i >= 0; i--)
     {
      if(!OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
         continue;

      // 自分のEAかつ現在の通貨ペアのポジションか確認
      if(OrderSymbol() != Symbol() || OrderMagicNumber() != MAGIC_NUMBER)
         continue;

      // 現在の利益pipsを計算
      double profitPips = 0;
      if(OrderType() == OP_BUY)
         profitPips = (Bid - OrderOpenPrice()) / Point / 10;
      else if(OrderType() == OP_SELL)
         profitPips = (OrderOpenPrice() - Ask) / Point / 10;

      // OrderLots関数でロット数を確認し、初期ロットから減っていなければ部分決済
      double initialLot = 0.10; // 初期エントリーロット数
      double currentLots = OrderLots();

      // 利益が目標に達し、かつまだ部分決済していない場合
      if(profitPips >= PartialCloseProfit && currentLots >= initialLot)
        {
         PartialClose(OrderTicket());
        }
     }
  }

部分決済では、OrderLots関数で取得したロット数を元に「半分のロット数」を計算しています。ブローカーの最小ロット数を下回らないようチェックすることがポイントです。

例4：ポジション情報をチャート上に一覧表示するインジケーター

デバッグや運用監視に便利な、保有中のポジション情報をチャート上に表示するインジケーターです。OrderLots関数を使ってロット数を取得し、各ポジションの詳細を一覧で確認できます。

//+------------------------------------------------------------------+
//| ポジション情報一覧表示インジケーター                               |
//+------------------------------------------------------------------+
#property indicator_chart_window // チャートウィンドウに表示

//+------------------------------------------------------------------+
//| カスタムインジケーター初期化関数                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   // 表示更新用のタイマーを1秒ごとに設定
   EventSetTimer(1);
   return(INIT_SUCCEEDED);
  }

//+------------------------------------------------------------------+
//| カスタムインジケーター終了処理                                     |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   // チャートのコメントをクリア
   Comment("");
   EventKillTimer();
  }

//+------------------------------------------------------------------+
//| タイマーイベントで定期的に情報を更新                               |
//+------------------------------------------------------------------+
void OnTimer()
  {
   DisplayPositionInfo();
  }

//+------------------------------------------------------------------+
//| メインの計算関数（インジケーター必須）                             |
//+------------------------------------------------------------------+
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[])
  {
   return(rates_total);
  }

//+------------------------------------------------------------------+
//| ポジション情報をチャートに表示する関数                             |
//+------------------------------------------------------------------+
void DisplayPositionInfo()
  {
   string info = "===== ポジション情報一覧 =====\n"; // 表示用文字列
   double totalLots   = 0.0; // 合計ロット数
   double totalProfit = 0.0; // 合計損益
   int    posCount    = 0;   // ポジション数カウンター

   // 全ポジションをループ
   for(int i = 0; i < OrdersTotal(); i++)
     {
      // ポジションを選択
      if(!OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
         continue;

      // 現在の通貨ペアのポジションのみ対象
      if(OrderSymbol() != Symbol())
         continue;

      // 成行注文（BUYまたはSELL）のみ対象
      if(OrderType() != OP_BUY && OrderType() != OP_SELL)
         continue;

      posCount++; // ポジション数をカウント

      // OrderLots関数でロット数を取得
      double lots   = OrderLots();
      double profit = OrderProfit() + OrderSwap() + OrderCommission();

      // 注文タイプを文字列に変換
      string typeStr = (OrderType() == OP_BUY) ? "BUY" : "SELL";

      // 各ポジションの情報を1行ずつ追加
      info += StringFormat("#%d | %s | %.2f lots | 建値:%.5f | 損益:%.0f円 | Magic:%d\n",
                           OrderTicket(),           // チケット番号
                           typeStr,                  // 売買方向
                           lots,                     // ロット数（OrderLots関数）
                           OrderOpenPrice(),         // エントリー価格
                           profit,                   // 損益
                           OrderMagicNumber());      // マジックナンバー

      // 合計値を加算
      totalLots   += lots;
      totalProfit += profit;
     }

   // 合計情報を追加
   info += "==============================\n";
   info += StringFormat("ポジション数: %d\n", posCount);
   info += StringFormat("合計ロット数: %.2f lots\n", totalLots);
   info += StringFormat("合計損益: %.0f円\n", totalProfit);

   // チャートに表示
   Comment(info);
  }

このインジケーターをチャートにセットすると、保有中の全ポジションのロット数・損益・チケット番号などがリアルタイムで一覧表示されます。複数のEAを同時に稼働させているときの状況把握に非常に役立ちます。

例5：ナンピンEAで前回ロットの倍でエントリーする

マーチンゲール戦略のナンピンEAでは、前回のポジションのロット数を取得して、次のエントリーを倍のロット数で行います。OrderLots関数を使って最新ポジションのロット数を確認する実用的なパターンです。

#define MAGIC_NUMBER 99999 // マジックナンバー
input double BaseLot       = 0.01; // 基本ロット数
input double LotMultiplier = 2.0;  // ロット倍率（マーチンゲール係数）
input double MaxLot        = 1.0;  // 最大ロット数（安全上限）
input int    NanpinPips    = 30;   // ナンピン間隔（pips）

//+------------------------------------------------------------------+
//| 最新ポジションのロット数を取得する関数                             |
//+------------------------------------------------------------------+
double GetLastPositionLots()
  {
   datetime latestTime = 0; // 最新のオープン時間を保持
   double   lastLots   = 0; // 最新ポジションのロット数

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

      // 自分のEAかつ現在の通貨ペアか確認
      if(OrderSymbol() != Symbol() || OrderMagicNumber() != MAGIC_NUMBER)
         continue;

      // 成行注文のみ対象
      if(OrderType() != OP_BUY && OrderType() != OP_SELL)
         continue;

      // より新しいポジションを見つけたら更新
      if(OrderOpenTime() > latestTime)
        {
         latestTime = OrderOpenTime();
         // OrderLots関数で最新ポジションのロット数を取得
         lastLots = OrderLots();
        }
     }

   return lastLots; // 最新ポジションのロット数を返す
  }

//+------------------------------------------------------------------+
//| 最新ポジションの建値を取得する関数                                 |
//+------------------------------------------------------------------+
double GetLastPositionPrice()
  {
   datetime latestTime  = 0;
   double   lastPrice   = 0;

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

      if(OrderSymbol() != Symbol() || OrderMagicNumber() != MAGIC_NUMBER)
         continue;

      if(OrderType() != OP_BUY && OrderType() != OP_SELL)
         continue;

      if(OrderOpenTime() > latestTime)
        {
         latestTime = OrderOpenTime();
         lastPrice  = OrderOpenPrice();
        }
     }

   return lastPrice;
  }

//+------------------------------------------------------------------+
//| 保有ポジション数を取得する関数                                     |
//+------------------------------------------------------------------+
int CountPositions()
  {
   int count = 0;

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

      if(OrderSymbol() == Symbol() && OrderMagicNumber() == MAGIC_NUMBER)
        {
         if(OrderType() == OP_BUY || OrderType() == OP_SELL)
            count++;
        }
     }

   return count;
  }

//+------------------------------------------------------------------+
//| OnTick - ナンピン買いのロジック例                                  |
//+------------------------------------------------------------------+
void OnTick()
  {
   int posCount = CountPositions();

   // ポジションが0のとき：基本ロットで初回エントリー
   if(posCount == 0)
     {
      // ここにエントリー条件を記述（例として常にBUY）
      int ticket = OrderSend(Symbol(), OP_BUY, BaseLot, Ask, 10, 0, 0,
                             "Nanpin EA", MAGIC_NUMBER, 0, clrBlue);
      if(ticket > 0)
         Print("初回エントリー成功 ロット:", DoubleToString(BaseLot, 2));
      return;
     }

   // ポジションが1つ以上あるとき：ナンピン条件を確認
   double lastPrice = GetLastPositionPrice();
   double lastLots  = GetLastPositionLots();

   // 最新ポジションからナンピン間隔分だけ逆行したか確認
   double nanpinDistance = NanpinPips * Point * 10;

   if(Ask <= lastPrice - nanpinDistance)
     {
      // OrderLots関数で取得した前回ロットに倍率をかける
      double nextLot = NormalizeDouble(lastLots * LotMultiplier, 2);

      // 最大ロット数を超えないよう制限
      if(nextLot > MaxLot)
         nextLot = MaxLot;

      // ナンピンエントリー
      int ticket = OrderSend(Symbol(), OP_BUY, nextLot, Ask, 10, 0, 0,
                             "Nanpin EA", MAGIC_NUMBER, 0, clrGreen);
      if(ticket > 0)
         Print("ナンピンエントリー成功 ロット:", DoubleToString(nextLot, 2),
               " 前回ロット:", DoubleToString(lastLots, 2));
     }

   // チャートに情報を表示
   Comment("ポジション数: ", posCount,
           "\n最新ロット: ", DoubleToString(lastLots, 2),
           "\n最新建値: ", DoubleToString(lastPrice, 5));
  }

このプログラムでは、GetLastPositionLots関数の中でOrderLots関数を使い、最新ポジションのロット数を取得しています。そのロット数に倍率をかけることで、マーチンゲール方式のナンピンを実現しています。MaxLotで上限を設けることで、ロット数が際限なく増えることを防いでいる点もポイントです。

まとめ

OrderLots関数は、選択したポジションのロット数を取得するシンプルな関数ですが、EA開発では非常に多くの場面で活躍します。

特に以下の3つの場面で使うことが多いので、しっかり覚えておきましょう。

1. ポジションの決済時：OrderClose関数の引数としてロット数を指定する
2. リスク管理：合計ロット数を計算して、上限を超えないよう制御する
3. ナンピン・マーチンゲール：前回のロット数を基に次のエントリーロットを計算する

OrderLots関数を使う前には、必ずOrderSelect関数でポジションを選択することを忘れないようにしましょう。

投稿 【MQL4関数】OrderLots関数の使い方！ポジションのロット数の取得方法 は 自動売買を作ろう！ に最初に表示されました。