MQL5 Variables, Types & Operators

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. It supplies the built-ins MetaTrader would provide, so real MQL5 compiles with an ordinary C++ compiler. If you already have it from the getting-started page, use that copy and skip ahead.

// 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, not a program. Confirm it saved with ls mql5.h (Windows: dir mql5.h).

This runs the MQL5 language on your own machine. It is not MetaTrader: no charts, no prices, no orders. Real Expert Advisors are still compiled in MetaEditor and tested on a demo account — but the language mistakes below are far quicker to meet here.

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. Check with g++ --version.

Go: the same folder.

Do: save this as build.sh. It compiles a .mq5 file and executes the result, using whichever C++ compiler you have. 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. Confirm both files are present with ls (Windows: dir); you should see mql5.h and build.sh.

It tries g++ and falls back to clang++, so one command works on Linux, macOS and inside the Windows Subsystem for Linux. The command underneath is g++ -x c++ -std=c++17 -o NAME NAME.mq5 — the -x c++ is what makes a compiler accept a .mq5 file.

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

Go: the same folder.

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

#include "mql5.h"

//+------------------------------------------------------------------+
//| Which type for which job. Getting this wrong is most EA bugs.     |
//+------------------------------------------------------------------+
void OnStart()
{
    double price   = 1.10250;      // prices ALWAYS double -- never int
    double lot     = 0.01;         // volumes too
    int    bars    = 500;          // counts are whole numbers
    int    ticket  = 123456789;    // ids are whole numbers
    long   big_id  = 9007199254740993;
    datetime when  = 1700000000;   // seconds since 1970
    string symbol  = "EURUSD";
    bool   allowed = true;

    Print("price   ", DoubleToString(price, 5), "   (double: keeps 5 decimals)");
    Print("lot     ", DoubleToString(lot, 2),   "   (double: 0.01 is a real volume)");
    Print("bars    ", bars,                     "   (int: you cannot have 2.5 bars)");
    Print("ticket  ", ticket);
    Print("big_id  ", big_id,                   "   (long: int would overflow)");
    Print("when    ", when);
    Print("symbol  ", symbol);
    Print("allowed ", allowed ? "true" : "false");
    Print("");

    // What happens if you pick int for a price:
    int as_int = (int)price;
    Print("price stored as int : ", as_int, "   <- 0.10250 is gone");
    Print("");
    Print("Rule of thumb: if it can have a fraction, it is a double.");
    Print("In trading code that is prices, volumes, money and percentages --");
    Print("which is nearly everything except bar counts and array indexes.");
}

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

You should see: each value printed with the precision its type allows:

price   1.10250   (double: keeps 5 decimals)
lot     0.01   (double: 0.01 is a real volume)
bars    500   (int: you cannot have 2.5 bars)
ticket  123456789
big_id  9007199254740993   (long: int would overflow)
when    1700000000
symbol  EURUSD
allowed true

price stored as int : 1   <- 0.10250 is gone

Rule of thumb: if it can have a fraction, it is a double.
In trading code that is prices, volumes, money and percentages --
which is nearly everything except bar counts and array indexes.

The rule at the bottom is worth committing to memory, because it removes a whole category of bug: if a value can have a fraction, it is a double. In trading code that means prices, volumes, money, percentages, stop distances and profit — nearly everything except bar counts and array indexes.

Two types deserve a note. long exists because order tickets and position identifiers on some brokers exceed what an int can hold, and an overflowed ticket number silently refers to the wrong position. And MQL5 has a color type for drawing, which is a whole number underneath — it is not included in the shim, so use it in MetaEditor rather than here.

If not: if big_id prints a smaller or negative number, it was declared as int rather than long — which is precisely the overflow described above, and worth causing on purpose once.

Go: the same folder.

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

#include "mql5.h"

//+------------------------------------------------------------------+
//| Two loop directions, and why only one is right for series arrays. |
//+------------------------------------------------------------------+
void OnStart()
{
    // A series array: index 0 is the NEWEST bar (ArraySetAsSeries(arr, true)).
    std::vector<double> close = {14.0, 13.0, 12.0, 11.0, 10.0};   // now .. oldest
    int total = ArraySize(close);

    Print("forward loop (0 upward) -- walks BACK in time:");
    for(int i = 0; i < total; i++)
        Print("   i=", i, " close=", DoubleToString(close[i], 1),
              i == 0 ? "   <- the current bar" : "");

    Print("");
    Print("backward loop (total-1 down to 0) -- walks FORWARD in time:");
    for(int i = total - 1; i >= 0; i--)
        Print("   i=", i, " close=", DoubleToString(close[i], 1),
              i == 0 ? "   <- ends on the current bar" : "");

    Print("");
    Print("Indicators calculate OLDEST first, so they loop DOWNWARD from");
    Print("total-1 to 0. Getting this backwards produces an indicator whose");
    Print("values depend on bars that had not happened yet -- which is how");
    Print("a backtest ends up looking miraculous.");
    Print("");

    // Every Nth bar, using modulo.
    Print("acting only every 3rd bar:");
    for(int i = total - 1; i >= 0; i--)
        if(i % 3 == 0)
            Print("   bar ", i, " -> act");
}

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

You should see: the same array walked in both directions:

forward loop (0 upward) -- walks BACK in time:
   i=0 close=14.0   <- the current bar
   i=1 close=13.0
   i=2 close=12.0
   i=3 close=11.0
   i=4 close=10.0

backward loop (total-1 down to 0) -- walks FORWARD in time:
   i=4 close=10.0
   i=3 close=11.0
   i=2 close=12.0
   i=1 close=13.0
   i=0 close=14.0   <- ends on the current bar

Indicators calculate OLDEST first, so they loop DOWNWARD from
total-1 to 0. Getting this backwards produces an indicator whose
values depend on bars that had not happened yet -- which is how
a backtest ends up looking miraculous.

acting only every 3rd bar:
   bar 3 -> act
   bar 0 -> act

In a series array index 0 is the current bar and higher indexes go further into the past. So counting up from zero walks backwards in time, and counting down to zero walks forwards.

Indicators must calculate oldest-first, which means looping downward from total-1 to 0. That is not a style preference. A calculation that runs the other way can use a value it has not legitimately computed yet, and the result is an indicator that appears to predict the market in a backtest and does nothing in live trading — the single most common cause of a strategy that “worked in testing”.

The modulo block at the end is the idiom for “act only every N bars”, which is how you stop an EA reacting to every tick without keeping a separate counter.

If not: if both loops print in the same order, one of the for headers was copied twice — the second must start at total - 1, test i >= 0 and decrement.

Go: the same folder. This one costs people real money.

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

#include "mql5.h"

//+------------------------------------------------------------------+
//| The bug that makes an EA open a position on every single tick.    |
//+------------------------------------------------------------------+

int    global_trades = 0;       // survives between ticks
static int static_trades = 0;   // same effect, visible only in this file

void OnTick_wrong()
{
    int trades_today = 0;       // RESET on every tick -- this is the bug
    if(trades_today < 1)
    {
        trades_today++;
        Print("   WRONG: opening a trade. trades_today is now ", trades_today);
    }
}

void OnTick_right()
{
    if(global_trades < 1)
    {
        global_trades++;
        Print("   RIGHT: opening a trade. global_trades is now ", global_trades);
    }
    else
        Print("   RIGHT: already have ", global_trades, " -- doing nothing");
}

void OnStart()
{
    Print("five ticks arrive, one after another.");
    Print("");
    Print("with the counter declared INSIDE the function:");
    for(int tick = 1; tick <= 5; tick++)
        OnTick_wrong();

    Print("");
    Print("with the counter declared OUTSIDE it:");
    for(int tick = 1; tick <= 5; tick++)
        OnTick_right();

    Print("");
    Print("A variable declared inside a function is created fresh each time");
    Print("the function runs. OnTick() runs on every price change -- dozens of");
    Print("times a minute -- so anything you want REMEMBERED between ticks must");
    Print("live outside it, or be declared static.");
}

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

You should see: the same counter reaching 1 five times, then behaving:

five ticks arrive, one after another.

with the counter declared INSIDE the function:
   WRONG: opening a trade. trades_today is now 1
   WRONG: opening a trade. trades_today is now 1
   WRONG: opening a trade. trades_today is now 1
   WRONG: opening a trade. trades_today is now 1
   WRONG: opening a trade. trades_today is now 1

with the counter declared OUTSIDE it:
   RIGHT: opening a trade. global_trades is now 1
   RIGHT: already have 1 -- doing nothing
   RIGHT: already have 1 -- doing nothing
   RIGHT: already have 1 -- doing nothing
   RIGHT: already have 1 -- doing nothing

A variable declared inside a function is created fresh each time
the function runs. OnTick() runs on every price change -- dozens of
times a minute -- so anything you want REMEMBERED between ticks must
live outside it, or be declared static.

OnTick() runs on every price change — many times a minute on a liquid instrument. A variable declared inside it is created fresh each time, so a counter written that way is always zero when it is tested, the guard always passes, and the EA opens a position on every tick until the account has no margin left.

Anything that must be remembered between ticks lives outside the function, or is declared static inside it. That includes trade counters, the time of the last signal, the bar number you last acted on, and any flag meaning “already done”.

The related habit worth adopting now: rather than counting your own trades, ask the terminal what positions exist — PositionsTotal() and PositionSelectByTicket(). A counter can disagree with reality after a restart; the terminal cannot.

If not: if the “wrong” block prints an increasing number, the variable was declared outside the function — which is the fix, so move it back inside to see the failure it is fixing.

Go: the same folder.

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

#include "mql5.h"

//+------------------------------------------------------------------+
//| input parameters: what the user types, and why you must check it. |
//+------------------------------------------------------------------+

// In MetaTrader these appear in the EA's settings dialog. The shim maps
// `input` to `static`, so the same declarations compile here.
input double RiskPercent = 2.0;
input int    MaPeriod    = 20;
input double LotSize     = 0.10;

bool ValidateInputs(double risk, int period, double lot)
{
    if(risk <= 0.0 || risk > 10.0)
    { Print("   REJECT: RiskPercent ", DoubleToString(risk, 2), " outside 0-10"); return false; }
    if(period < 2)
    { Print("   REJECT: MaPeriod ", period, " must be at least 2"); return false; }
    if(lot <= 0.0)
    { Print("   REJECT: LotSize ", DoubleToString(lot, 2), " must be positive"); return false; }
    Print("   accepted");
    return true;
}

void OnStart()
{
    Print("the values you shipped as defaults:");
    ValidateInputs(RiskPercent, MaPeriod, LotSize);

    Print("");
    Print("what a user might actually type:");
    Print("  risk 200 (meaning 200%, or a typo for 2.00):");
    ValidateInputs(200.0, MaPeriod, LotSize);
    Print("  period 0 (left blank):");
    ValidateInputs(RiskPercent, 0, LotSize);
    Print("  lot -0.1 (a stray minus):");
    ValidateInputs(RiskPercent, MaPeriod, -0.1);

    Print("");
    Print("Every one of those is something a person will type. An EA that");
    Print("does not check its own inputs will happily compute a position size");
    Print("from them -- and MaPeriod 0 divides by zero inside your average.");
    Print("");
    Print("Validate in OnInit() and return INIT_PARAMETERS_INCORRECT, so the");
    Print("EA refuses to start rather than starting and behaving strangely.");
}

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

You should see: three plausible entries rejected:

the values you shipped as defaults:
   accepted

what a user might actually type:
  risk 200 (meaning 200%, or a typo for 2.00):
   REJECT: RiskPercent 200.00 outside 0-10
  period 0 (left blank):
   REJECT: MaPeriod 0 must be at least 2
  lot -0.1 (a stray minus):
   REJECT: LotSize -0.10 must be positive

Every one of those is something a person will type. An EA that
does not check its own inputs will happily compute a position size
from them -- and MaPeriod 0 divides by zero inside your average.

Validate in OnInit() and return INIT_PARAMETERS_INCORRECT, so the
EA refuses to start rather than starting and behaving strangely.

input variables appear in the EA's settings dialog, which means their values come from a person, at speed, possibly at two in the morning. All three rejected examples are ordinary mistakes: 200 typed for 2.00, a field left at zero, a stray minus sign.

The zero is the dangerous one. A moving-average period of zero divides by zero inside the calculation, and depending on where that happens you get an infinity, a not-a-number, or a comparison that is false forever — none of which announces itself.

In a real EA this check belongs in OnInit(), returning INIT_PARAMETERS_INCORRECT so the terminal refuses to start it and says why. An EA that starts with impossible settings and then behaves oddly is far harder to diagnose than one that declines to start at all.

If not: if everything is accepted, the comparison operators were relaxed — the risk check needs both bounds, since a negative risk and a 200% risk are different mistakes and both must fail.