Nouveau : la formation trading algorithmique MQL5, MQL4 et ProRealTimeDécouvrir →

MQL5 · Bases du langage

Préprocesseur MQL5 : #include, #define, #property et compilation conditionnelle

Déclarer les propriétés d’un programme, réutiliser du code avec #include, définir constantes et macros avec #define et activer du code de débogage avec #ifdef : règles, chemins de recherche et pièges.

Mis à jour le 23 octobre 2026Lecture : 8 minPar Alix, OptiBot Trading

Les directives du préprocesseur sont des lignes commençant par #, traitées avant la compilation proprement dite. Les trois que vous utiliserez dans tout programme MQL5 sont #property, qui déclare les propriétés du programme (version, copyright, description, type d’affichage d’un indicateur), #include, qui insère le contenu d’un autre fichier (typiquement un .mqh de la bibliothèque standard ou de votre propre code), et #define, qui associe un nom à une valeur ou à une expression par simple substitution de texte. S’y ajoutent la compilation conditionnelle (#ifdef, #ifndef, #else, #endif) et #import pour les fonctions externes.

Cette page fait partie de la rubrique Les bases du langage MQL5.

Règles générales

La documentation pose trois règles simples. Une directive commence toujours par #. Elle s’étend jusqu’à la fin de la ligne, et l’on ne peut pas placer plusieurs directives sur une même ligne. Une directive trop longue peut être continuée à la ligne suivante en terminant la ligne par une barre oblique inverse \.

Les directives sont traitées par le préprocesseur avant le compilateur. Elles ne génèrent donc pas de code exécutable par elles-mêmes : elles modifient le texte que le compilateur va lire, ou les métadonnées du fichier .ex5 produit.

#property : les propriétés du programme

Les propriétés renseignent le terminal sur le programme. Les plus courantes pour un Expert Advisor ou un script sont :

PropriétéRôle selon la documentation
copyrightNom de l’auteur ou de la société
linkLien vers le site de l’auteur
versionVersion du programme, 31 caractères maximum
descriptionDescription courte ; peut être répétée, 511 caractères au total
iconChemin d’une image ICO utilisée comme icône du programme
script_show_inputsAffiche la fenêtre des paramètres avant le lancement d’un script
script_show_confirmAffiche une confirmation avant le lancement d’un script
stacksizeTaille de la pile, en octets, pour un EA ou un script

Les indicateurs disposent de propriétés propres : indicator_chart_window ou indicator_separate_window pour la fenêtre d’affichage, indicator_buffers pour le nombre de buffers de calcul et indicator_plots pour le nombre de séries tracées. Elles sont détaillées dans Buffers et styles de tracé.

Le Strategy Tester utilise lui aussi des propriétés : tester_indicator déclare un indicateur personnalisé nécessaire au test (la documentation précise qu’il est détecté automatiquement lorsque iCustom() reçoit un nom constant), tester_file transmet un fichier aux agents de test, et tester_set associe un fichier de paramètres.

Une règle documentée est souvent ignorée : les propriétés doivent figurer dans le fichier principal .mq5. Celles qui sont placées dans un fichier inclus sont ignorées.

#include : réutiliser du code

#include insère à cet endroit le contenu d’un autre fichier. La documentation distingue deux formes :

  • #include <Trade\Trade.mqh> : entre chevrons, le fichier est cherché dans le dossier standard MQL5\Include du terminal, et le dossier courant n’est pas inclus dans la recherche ;
  • #include "MesOutils.mqh" : entre guillemets, le fichier est cherché dans le dossier du fichier source principal, et le dossier standard est ignoré.

La première forme sert pour la bibliothèque standard (par exemple la classe CTrade) et pour vos bibliothèques partagées entre plusieurs projets, rangées dans MQL5\Include. La seconde sert pour les fichiers propres à un projet, placés à côté du .mq5.

Un fichier .mqh ne se compile pas seul en programme : il contient des déclarations (fonctions, classes, énumérations, structures) destinées à être incluses. Découper un EA en plusieurs fichiers (signaux, gestion du risque, journalisation) rend le code plus facile à maintenir et à réutiliser.

#define : substitution de texte

Forme constante

#define NOM expression remplace chaque occurrence isolée de NOM par expression. La documentation insiste sur un piège : l’expression n’est pas mise entre parenthèses automatiquement. Avec #define SOMME 2+3, l’expression SOMME*2 devient 2+3*2, soit 8 et non 10. La parade est simple : écrivez toujours #define SOMME (2+3).

Forme paramétrique

#define NOM(a, b) expression fonctionne comme une petite macro. La documentation limite le nombre de paramètres à huit et recommande de placer chaque paramètre entre parenthèses dans l’expression, faute de quoi le résultat peut changer silencieusement. Par exemple : #define MAX2(a, b) ((a) > (b) ? (a) : (b)).

#undef

#undef NOM annule une définition précédente. Après cette ligne, le nom n’est plus substitué et un test #ifdef NOM échoue.

Pour une simple constante numérique, une variable const typée est souvent préférable : elle respecte les types et la portée. #define reste utile pour les tailles de tableaux statiques, les drapeaux de compilation conditionnelle et les petites macros. La comparaison est développée dans Variables, constantes et portée.

Compilation conditionnelle

#ifdef NOM compile le bloc qui suit jusqu’à #endif (ou #else) seulement si NOM a été défini par #define. #ifndef NOM fait l’inverse. La documentation décrit des identifiants prédéfinis très utiles dans ce contexte : __MQL5__ est défini lors de la compilation d’un fichier .mq5 et __MQL4__ pour un fichier .mq4, ce qui permet d’écrire un fichier inclus compatible avec les deux langages ; _DEBUG est défini lors d’une compilation en mode débogage et _RELEASE en mode normal.

Le cas d’usage le plus courant est la journalisation détaillée : on l’active pendant le développement et elle disparaît du programme final, sans aucun coût d’exécution.

Les macros prédéfinies

Le compilateur fournit des macros qui facilitent le diagnostic : __FILE__ (nom du fichier compilé), __LINE__ (numéro de ligne), __FUNCTION__ (nom de la fonction courante), __FUNCSIG__ (signature complète), __DATE__ et __DATETIME__ (date de compilation), __MQLBUILD__ (numéro de build du compilateur). Intégrées à vos messages d’erreur, elles indiquent immédiatement d’où vient le problème.

Exemple complet : un EA et son fichier inclus

Fichier Outils.mqh, placé dans le même dossier que l’EA :

//+------------------------------------------------------------------+
//| Outils.mqh : fonctions partagees, inclus par l'EA                |
//+------------------------------------------------------------------+
#ifndef OUTILS_MQH            // garde d'inclusion : evite une double inclusion
#define OUTILS_MQH

#define MAX2(a, b) ((a) > (b) ? (a) : (b))   // parametres entre parentheses

//--- Journalisation detaillee uniquement en compilation de debogage
#ifdef _DEBUG
   #define LOG_DEBUG(msg) Print(__FUNCTION__, " [", __LINE__, "] ", msg)
#else
   #define LOG_DEBUG(msg)
#endif

double DistancePoints(double prix1, double prix2)
  {
   return(MathAbs(prix1 - prix2) / _Point);
  }

#endif // OUTILS_MQH

Fichier principal MonEA.mq5 :

//+------------------------------------------------------------------+
//| MonEA.mq5 : proprietes, inclusions et constantes                 |
//+------------------------------------------------------------------+
#property copyright   "Votre nom"
#property link        "https://www.example.com"
#property version     "1.20"
#property description "EA de demonstration du preprocesseur"

#include <Trade\Trade.mqh>     // bibliotheque standard : dossier MQL5\Include
#include "Outils.mqh"          // fichier du projet : dossier du fichier principal

#define NB_BARRES 20           // taille du tableau statique ci-dessous

input int InpSpreadMax = 25;   // Spread maximum (points)

CTrade g_trade;
double g_plusHauts[NB_BARRES];

int OnInit()
  {
   PrintFormat("%s compile le %s avec le build %d",
               __FILE__, TimeToString(__DATETIME__), __MQLBUILD__);
   LOG_DEBUG("initialisation terminee");
   return(INIT_SUCCEEDED);
  }

void OnTick()
  {
   MqlTick tick;
   if(!SymbolInfoTick(_Symbol, tick))
      return;
   double spreadPts = DistancePoints(tick.ask, tick.bid);
   LOG_DEBUG(StringFormat("spread = %.1f points", spreadPts));
   if(spreadPts > MAX2(InpSpreadMax, 1))
      return;
   // ... logique de trading avec g_trade
  }

La garde d’inclusion (#ifndef OUTILS_MQH / #define OUTILS_MQH / #endif) empêche le contenu d’être inséré deux fois si plusieurs fichiers incluent Outils.mqh. La macro LOG_DEBUG produit des messages précis, avec la fonction et la ligne, uniquement dans les compilations de débogage ; en compilation normale, elle est remplacée par rien. Les modes de compilation sont présentés dans Bien utiliser MetaEditor.

Pièges fréquents

  • Macro sans parenthèses : #define DOUBLE(x) x*2 appliqué à DOUBLE(1+2) donne 5. Écrivez ((x)*2).
  • #property dans un fichier inclus : ignorée. Gardez-les dans le .mq5.
  • Chevrons ou guillemets inversés : #include "Trade\Trade.mqh" cherche dans le dossier du projet et échoue. Utilisez les chevrons pour la bibliothèque standard.
  • Point-virgule dans un #define : #define PERIODE 14; insère le point-virgule partout où PERIODE apparaît, ce qui casse les expressions.
  • Double inclusion : sans garde, la redéclaration d’une fonction ou d’une énumération provoque une erreur de compilation.

FAQ

Quelle différence entre #include avec chevrons et avec guillemets ?

Avec des chevrons, le fichier est cherché dans le dossier standard MQL5\Include, sans regarder le dossier courant. Avec des guillemets, il est cherché dans le dossier du fichier source principal, sans regarder le dossier standard.

Pourquoi mes #property ne sont-elles pas prises en compte ?

Elles se trouvent probablement dans un fichier inclus. La documentation précise que les propriétés doivent être déclarées dans le fichier principal .mq5 ; celles des fichiers inclus sont ignorées.

Faut-il préférer #define ou const pour une constante ?

Pour une valeur numérique utilisée dans les calculs, const est plus sûr car typé et soumis à la portée. #define reste nécessaire pour la compilation conditionnelle et pratique pour les tailles de tableaux statiques ou les petites macros.

Comment activer du code uniquement pendant le débogage ?

Entourez-le de #ifdef _DEBUG et #endif. La macro _DEBUG est définie lors d’une compilation en mode débogage ; en compilation normale, c’est _RELEASE qui est défini et le bloc disparaît.

A

Alix · fondateur d’OptiBot Trading

Développeur MQL5 et ProBuilder, spécialiste du backtest et de l’optimisation de stratégies automatiques. Chaque contenu est vérifié sur la documentation officielle (MQL5.com, manuels ProRealTime) et testé avant publication. Notre méthode éditoriale.