Working with Price Data & Arrays

Go: open a terminal in a folder you can write to — cd ~/Desktop on macOS or Linux, cd %USERPROFILE%\Desktop on Windows.

Do: save this as mql5.h. If you already have it from an earlier page, reuse that copy and skip to step 3.

// mql5.h - a small shim that lets a useful SUBSET of MQL5 compile and run
// with an ordinary C++ compiler, so you can practise the language without
// MetaTrader. It is NOT MetaTrader and does not trade anything.
#pragma once
#include <cstdio>
#include <cmath>
#include <string>
#include <vector>
#include <iostream>
#include <sstream>

typedef std::string string;
typedef long long datetime;
#define input static

template <typename T> int ArraySize(const std::vector<T> &a) { return (int)a.size(); }
template <typename T> void ArrayResize(std::vector<T> &a, int n) { a.resize(n); }

inline void Print() { std::cout << std::endl; }
template <typename T, typename... Rest>
void Print(const T &first, const Rest &...rest) {
    std::cout << first;
    if constexpr (sizeof...(rest) > 0) Print(rest...);
    else std::cout << std::endl;
}

inline string DoubleToString(double v, int digits = 8) {
    char buf[64]; snprintf(buf, sizeof buf, "%.*f", digits, v); return string(buf);
}
inline string IntegerToString(long long v) { return std::to_string(v); }
inline double MathAbs(double v)  { return std::fabs(v); }
inline double MathMax(double a, double b) { return a > b ? a : b; }
inline double MathMin(double a, double b) { return a < b ? a : b; }
inline int    MathRound(double v) { return (int)std::lround(v); }

You should see: nothing — this is a header file. Confirm with ls mql5.h (Windows: dir mql5.h).

If not: no compiler? On Ubuntu or Debian sudo apt install g++; on macOS xcode-select --install; on Windows use the Windows Subsystem for Linux or MSYS2.

Go: the same folder.

Do: save this as build.sh. It compiles a .mq5 file and executes the result. Make it executable with chmod +x build.sh, or invoke it as sh build.sh.

#!/bin/sh
# build.sh NAME  ->  compiles NAME.mq5 and runs it.
# MQL5 is close enough to C++ that a C++ compiler can run the subset used here,
# with mql5.h supplying the handful of built-ins MetaTrader would provide.
# Uses whichever compiler you have.
set -e
NAME="$1"
if command -v g++ >/dev/null 2>&1 && g++ -x c++ -std=c++17 -o "$NAME" "$NAME.mq5" 2>/dev/null; then
    :
elif command -v clang++ >/dev/null 2>&1; then
    clang++ -x c++ -std=c++17 -o "$NAME" "$NAME.mq5"
else
    echo "No C++ compiler found. Install g++ (Linux: apt install g++, macOS: xcode-select --install)." >&2
    exit 1
fi
"./$NAME"

You should see: nothing — this is the toolchain. ls should show both mql5.h and build.sh.

If not: Permission denied means the chmod was skipped; use sh build.sh NAME, which needs no execute bit.

Go: the same folder.

Do: save this as rates.mq5 and run sh build.sh rates.

#include "mql5.h"

//+------------------------------------------------------------------+
//| MqlRates: one bar, six fields. Copying it is how you read a chart.|
//+------------------------------------------------------------------+
struct MqlRates
{
    datetime time;
    double   open, high, low, close;
    long     tick_volume;
};

// Stands in for CopyRates(): fills `dest` newest-first, returns how many.
int CopyRates_stub(std::vector<MqlRates> &dest, int count)
{
    ArrayResize(dest, count);
    for(int i = 0; i < count; i++)
    {
        double base = 1.1000 + (count - 1 - i) * 0.0005;
        dest[i].time        = 1700000000 + (count - 1 - i) * 3600;
        dest[i].open        = base;
        dest[i].close       = base + 0.0003;
        dest[i].high        = base + 0.0006;
        dest[i].low         = base - 0.0002;
        dest[i].tick_volume = 500 + i * 10;
    }
    return count;
}

void OnStart()
{
    std::vector<MqlRates> rates;
    int got = CopyRates_stub(rates, 5);

    Print("CopyRates returned : ", got);
    if(got <= 0) { Print("   nothing copied -- return and wait"); return; }

    Print("");
    Print("idx        time      open      high       low     close   volume");
    for(int i = 0; i < got; i++)
        Print("  ", i, "  ", rates[i].time,
              "  ", DoubleToString(rates[i].open, 4),
              "  ", DoubleToString(rates[i].high, 4),
              "  ", DoubleToString(rates[i].low, 4),
              "  ", DoubleToString(rates[i].close, 4),
              "     ", rates[i].tick_volume);

    Print("");
    Print("index 0 is the CURRENT bar. Its time is the LATEST, and each higher");
    Print("index steps one bar further into the past.");
}

int main() { OnStart(); return 0; }

You should see: five bars, newest first:

CopyRates returned : 5

idx        time      open      high       low     close   volume
  0  1700014400  1.1020  1.1026  1.1018  1.1023     500
  1  1700010800  1.1015  1.1021  1.1013  1.1018     510
  2  1700007200  1.1010  1.1016  1.1008  1.1013     520
  3  1700003600  1.1005  1.1011  1.1003  1.1008     530
  4  1700000000  1.1000  1.1006  1.0998  1.1003     540

index 0 is the CURRENT bar. Its time is the LATEST, and each higher
index steps one bar further into the past.

Two things to fix in your mind. First, the return value is checked before anything else touches the array — the real CopyRates returns -1 when history is not yet available, which happens on a fresh chart, after a reconnection, and on any symbol you have not opened before.

Second, the ordering. Index 0 carries the latest time and each higher index steps further into the past. That is the arrangement ArraySetAsSeries(arr, true) produces, and it is how nearly all MQL5 examples are written — but it is not automatic, so set it yourself immediately after every copy.

If not: if the times increase as the index increases, the fill loop is running the wrong way — the newest bar must be at index 0, which is what the count - 1 - i arithmetic arranges.

Go: the same folder. This is the most consequential fact on the page.

Do: save this as incomplete.mq5 and run sh build.sh incomplete.

#include "mql5.h"

//+------------------------------------------------------------------+
//| Bar 0 is still being built. Deciding on it is deciding on noise.  |
//+------------------------------------------------------------------+
void OnStart()
{
    // The same forming bar, sampled four times during the hour.
    double forming_close[4] = {1.1020, 1.1031, 1.1014, 1.1027};
    double previous_close   = 1.1018;

    Print("during one hour, bar 0's close changes as ticks arrive:");
    for(int t = 0; t < 4; t++)
    {
        bool above = forming_close[t] > previous_close;
        Print("   minute ", t * 15, "  close=", DoubleToString(forming_close[t], 4),
              "  'above previous close' -> ", above ? "YES" : "no");
    }

    Print("");
    Print("Four different answers to the same question, within one bar.");
    Print("An EA testing that condition on every tick will act on whichever");
    Print("answer happened when a tick arrived -- and in a backtest, on");
    Print("whichever answer the tester happened to model.");
    Print("");
    Print("Using bar 1 instead -- the last CLOSED bar:");
    Print("   close=", DoubleToString(previous_close, 4), "  -> one answer, forever");
    Print("");
    Print("This is the single biggest cause of a strategy that backtests well");
    Print("and fails live. It is not the strategy; it is that the backtest and");
    Print("the live account see different versions of bar 0.");
    Print("");
    Print("Rule: signals are calculated on CLOSED bars. Index 1, not 0.");
    Print("Detect a new bar by remembering the time of bar 0 and acting only");
    Print("when it changes.");
}

int main() { OnStart(); return 0; }

You should see: the same question answered three different ways inside one bar:

during one hour, bar 0's close changes as ticks arrive:
   minute 0  close=1.1020  'above previous close' -> YES
   minute 15  close=1.1031  'above previous close' -> YES
   minute 30  close=1.1014  'above previous close' -> no
   minute 45  close=1.1027  'above previous close' -> YES

Four different answers to the same question, within one bar.
An EA testing that condition on every tick will act on whichever
answer happened when a tick arrived -- and in a backtest, on
whichever answer the tester happened to model.

Using bar 1 instead -- the last CLOSED bar:
   close=1.1018  -> one answer, forever

This is the single biggest cause of a strategy that backtests well
and fails live. It is not the strategy; it is that the backtest and
the live account see different versions of bar 0.

Rule: signals are calculated on CLOSED bars. Index 1, not 0.
Detect a new bar by remembering the time of bar 0 and acting only
when it changes.

Bar 0's open is fixed the moment the bar starts, and its high and low can only widen — but its close is simply the latest price, and it moves continuously until the bar ends. Any comparison involving it is a comparison against a number that has not settled.

This explains a specific and very common experience. A strategy is described in terms of bars, tested in a tester that models bar 0 one way, and then run live where ticks arrive differently — and it behaves nothing like the test. The strategy was never the problem; the two environments were answering the question at different moments.

The fix is one word: use bar 1. It has closed, its values are final, and every environment agrees about them forever. You give up acting until the bar ends, which is exactly what a strategy described in terms of bars was always claiming to do.

If not: the numbers here are constants and cannot vary; if all four answers agree, the sample closes were edited so that none of them dips below previous_close, which removes the effect being shown.

Go: the same folder.

Do: save this as newbar.mq5 and run sh build.sh newbar.

#include "mql5.h"

//+------------------------------------------------------------------+
//| The new-bar guard: the four lines every EA should start with.     |
//+------------------------------------------------------------------+

datetime last_bar_time = 0;          // must survive between ticks

bool IsNewBar(datetime current_bar_time)
{
    if(current_bar_time == last_bar_time) return false;
    last_bar_time = current_bar_time;
    return true;
}

void OnStart()
{
    // Ten ticks. The bar changes twice.
    datetime ticks[10] = {1700000000, 1700000000, 1700000000,
                          1700003600, 1700003600, 1700003600, 1700003600,
                          1700007200, 1700007200, 1700007200};

    int acted = 0;
    for(int i = 0; i < 10; i++)
    {
        if(IsNewBar(ticks[i]))
        {
            acted++;
            Print("tick ", i, "  bar time ", ticks[i], "  -> NEW BAR, evaluate signal");
        }
        else
            Print("tick ", i, "  bar time ", ticks[i], "  -> same bar, do nothing");
    }

    Print("");
    Print("ticks processed : 10");
    Print("signals evaluated: ", acted);
    Print("");
    Print("Without this guard the signal is evaluated ten times and can fire");
    Print("ten times. With it, once per bar -- which is what a strategy");
    Print("described in terms of bars actually means.");
}

int main() { OnStart(); return 0; }

You should see: ten ticks producing three evaluations:

tick 0  bar time 1700000000  -> NEW BAR, evaluate signal
tick 1  bar time 1700000000  -> same bar, do nothing
tick 2  bar time 1700000000  -> same bar, do nothing
tick 3  bar time 1700003600  -> NEW BAR, evaluate signal
tick 4  bar time 1700003600  -> same bar, do nothing
tick 5  bar time 1700003600  -> same bar, do nothing
tick 6  bar time 1700003600  -> same bar, do nothing
tick 7  bar time 1700007200  -> NEW BAR, evaluate signal
tick 8  bar time 1700007200  -> same bar, do nothing
tick 9  bar time 1700007200  -> same bar, do nothing

ticks processed : 10
signals evaluated: 3

Without this guard the signal is evaluated ten times and can fire
ten times. With it, once per bar -- which is what a strategy
described in terms of bars actually means.

Four lines, and they belong at the top of almost every OnTick() you will write. Note that last_bar_time is declared outside the function — declared inside it, it would reset on every tick and the guard would never fire, which is the scope trap from the syntax page appearing again in a new costume.

In a real EA the bar time comes from iTime(_Symbol, PERIOD_CURRENT, 0), or from rates[0].time after a successful copy. Either way the logic is identical: remember it, compare it, and only evaluate the signal when it has changed.

Combine this with using bar 1 and a whole class of problem disappears at once. The signal is calculated once per bar, from values that are final, and the backtest and the live account are finally answering the same question.

If not: if all ten ticks report a new bar, last_bar_time was declared inside IsNewBar — move it back to file scope. If none do, the initial value was set to the first tick's time rather than 0.