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

MQL5 · Bases du langage

Variables, constantes et portée en MQL5 : locales, globales, static et const

Où déclarer une variable MQL5, combien de temps elle vit et qui peut la modifier : locales, globales, static, const et variables prédéfinies expliquées avec un exemple d’EA.

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

Une variable MQL5 se déclare avec un type et un nom, avant sa première utilisation : double stopLoss = 0.0;. Là où vous la déclarez détermine sa portée (le code qui peut la lire) et sa durée de vie (le moment où elle est créée et détruite). Une variable locale disparaît à la fin de son bloc, une variable globale vit aussi longtemps que le programme, et une variable locale static conserve sa valeur d’un appel à l’autre. Le mot-clé const interdit toute modification après l’initialisation. Bien maîtriser ces quatre notions évite la majorité des comportements « mystérieux » d’un Expert Advisor.

Cette page appartient à la rubrique Les bases du langage MQL5. Les types eux-mêmes sont décrits dans Types de données en MQL5.

Déclarer et initialiser une variable

La syntaxe est celle du C : le type, le nom, puis éventuellement une valeur initiale. Plusieurs variables du même type peuvent être déclarées sur une ligne, séparées par des virgules. Les noms sont sensibles à la casse : prix et Prix sont deux variables différentes.

L’initialisation mérite une attention particulière. La documentation officielle indique qu’une variable qui n’est pas initialisée explicitement peut contenir n’importe quelle valeur, et que l’initialisation implicite n’est pas utilisée. Les variables globales et static font exception : faute de valeur indiquée, elles démarrent à zéro. Pour les variables locales, prenez donc l’habitude d’initialiser systématiquement. Pour une structure, la forme MqlTradeRequest request = {}; remet tous les champs à zéro, comme le montre la documentation.

Variables locales

Une variable déclarée à l’intérieur d’un bloc entre accolades est locale à ce bloc. Elle n’est pas visible à l’extérieur et elle est recréée à chaque exécution du bloc. Une variable déclarée dans l’en-tête d’une boucle for(int i = 0; ...) n’existe que dans cette boucle. Les paramètres d’une fonction se comportent comme des variables locales.

Les variables locales sont stockées sur la pile. La documentation précise que la pile par défaut fait 8 Mo pour les Expert Advisors et les scripts, et 1 Mo pour les indicateurs ; la directive #property stacksize permet de la modifier pour les EA et les scripts. Pour des données volumineuses, la documentation recommande la mémoire dynamique (par exemple un tableau dynamique redimensionné avec ArrayResize()).

Une variable locale peut porter le même nom qu’une variable globale. Dans son bloc, c’est la locale qui est utilisée. Ce masquage est légal mais source de confusion : évitez-le, ou adoptez une convention de nommage (préfixe g_ pour les globales, par exemple).

Variables globales du programme

Une variable déclarée hors de toute fonction est globale : toutes les fonctions du fichier, et des fichiers inclus après sa déclaration, peuvent la lire et la modifier. Selon la documentation, elle est initialisée une seule fois, après le chargement du programme et avant le traitement de l’événement Init. Elle ne peut être initialisée qu’avec une constante ou une expression constante : appeler une fonction dans l’initialiseur d’une globale n’est pas permis. La bonne pratique consiste à déclarer int g_handleMA = INVALID_HANDLE; puis à appeler la fonction dans OnInit().

Attention à la confusion fréquente : ces variables globales du programme n’ont rien à voir avec les variables globales du terminal (GlobalVariableSet()), qui survivent à la fermeture du programme et sont partagées entre EA. Ces dernières sont traitées dans Variables globales du terminal.

Point important pour un EA : lorsque vous changez de timeframe ou modifiez les paramètres, le programme est désinitialisé puis réinitialisé. Une variable globale qui mémorisait un état (dernier signal, nombre de trades du jour) repart alors de sa valeur initiale. Si cet état doit survivre, il faut le reconstruire dans OnInit() à partir de l’historique ou le sauvegarder.

Variables static

Le mot-clé static appliqué à une variable locale lui donne la durée de vie d’une globale tout en gardant une portée locale. La documentation indique qu’elle est initialisée une seule fois, avant l’appel de OnInit(), avec une constante ou une expression constante, et qu’elle prend la valeur zéro si aucune valeur n’est indiquée. Elle conserve ensuite sa valeur entre deux appels de la fonction.

C’est l’outil idéal pour mémoriser une information propre à une fonction : l’heure d’ouverture de la dernière bougie traitée, un compteur de ticks, un horodatage de dernier message. La détection d’une nouvelle bougie utilise souvent ce mécanisme, comme expliqué dans Détecter une nouvelle bougie.

Constantes : const, #define et input

Le spécificateur const déclare une variable en lecture seule : elle reçoit sa valeur une seule fois, à la déclaration, et toute tentative de modification provoque une erreur de compilation. Sur un paramètre de fonction, const garantit à l’appelant que la fonction ne modifiera pas l’argument.

Trois mécanismes produisent des valeurs fixes, avec des rôles différents :

MécanismeNatureUsage typique
constVariable typée en lecture seuleConstante de calcul : const double PIP_FACTOR = 10.0;
#defineSubstitution de texte avant compilationTaille de tableau, drapeau de compilation
inputParamètre externe réglable par l’utilisateurPériode, risque, magic number

const est typée et suit les règles de portée ; #define est une substitution textuelle qui ignore les types, décrite dans la page consacrée au préprocesseur. Les paramètres input ne peuvent pas non plus être modifiés par le code : ils sont présentés dans Paramètres input et sinput.

Les variables prédéfinies

Le terminal fournit des variables prêtes à l’emploi, initialisées avant le démarrage du programme : _Symbol (symbole du graphique), _Period (timeframe), _Digits (nombre de décimales), _Point (taille d’un point), _LastError (dernier code d’erreur), _StopFlag et _UninitReason, entre autres. La documentation précise qu’elles sont constantes, à l’exception de _LastError, que l’on peut remettre à zéro avec ResetLastError().

Exemple complet : portée et durée de vie dans un EA

//+------------------------------------------------------------------+
//| EA de demonstration : locales, globales, static et const         |
//+------------------------------------------------------------------+
input int InpPeriodeMA = 20;               // Periode de la moyenne mobile

const int MAX_LOG = 5;                     // constante typee, non modifiable
int       g_handleMA     = INVALID_HANDLE; // globale initialisee par une constante
int       g_ticksTraites = 0;              // globale : vit tant que l'EA est charge

int OnInit()
  {
   // Les appels de fonction se font ici, pas dans l'initialiseur global
   g_handleMA = iMA(_Symbol, _Period, InpPeriodeMA, 0, MODE_SMA, PRICE_CLOSE);
   if(g_handleMA == INVALID_HANDLE)
      return(INIT_FAILED);
   return(INIT_SUCCEEDED);
  }

void OnTick()
  {
   g_ticksTraites++;                       // compteur global

   static datetime derniereBarre = 0;      // static : garde sa valeur entre les ticks
   datetime barreCourante = iTime(_Symbol, _Period, 0);   // locale : recreee a chaque tick

   if(barreCourante == derniereBarre)
      return;                              // meme bougie : rien a faire
   derniereBarre = barreCourante;

   static int nbMessages = 0;              // initialisee a 0 une seule fois
   if(nbMessages < MAX_LOG)
     {
      PrintFormat("Nouvelle bougie %s apres %d ticks",
                  TimeToString(barreCourante), g_ticksTraites);
      nbMessages++;
     }
  }

void OnDeinit(const int reason)
  {
   if(g_handleMA != INVALID_HANDLE)
      IndicatorRelease(g_handleMA);        // liberation du handle
  }

Dans cet exemple, barreCourante est recréée à chaque tick, derniereBarre et nbMessages survivent d’un tick à l’autre sans être visibles hors de OnTick(), et g_handleMA est partagé entre les trois fonctions événementielles.

Pièges fréquents

  • Variable locale non initialisée : son contenu est indéterminé. Un double sl; utilisé sans affectation dans une branche de if peut envoyer un stop aberrant au serveur.
  • Globale initialisée avec une fonction : refusé par le compilateur. Déplacez l’appel dans OnInit().
  • État perdu au changement de timeframe : les globales et les static sont réinitialisées avec le programme. Ne comptez pas sur elles pour mémoriser durablement un nombre de trades.
  • Masquage de nom : une locale lot qui masque une globale lot donne des résultats incohérents difficiles à repérer. Utilisez des préfixes.
  • Abus de globales : un état partagé par vingt fonctions devient vite ingérable. Passez plutôt les valeurs en paramètres, comme expliqué dans la page consacrée aux fonctions.

FAQ

Quelle est la valeur d’une variable locale non initialisée ?

Elle est indéterminée : la documentation indique qu’elle peut contenir n’importe quelle valeur. Seules les variables globales et static démarrent à zéro lorsqu’aucune valeur n’est indiquée. Initialisez toujours vos variables locales.

Pourquoi ma variable globale est-elle remise à zéro ?

Parce que l’EA a été désinitialisé puis réinitialisé : changement de symbole ou de timeframe, modification des paramètres, recompilation ou changement de compte. Toutes les globales retrouvent alors leur valeur initiale.

Quelle différence entre const et #define ?

const crée une vraie variable typée, en lecture seule, soumise aux règles de portée. #define remplace un nom par du texte avant la compilation, sans vérification de type. Préférez const pour les valeurs numériques et réservez #define à la compilation conditionnelle ou aux tailles de tableaux.

Une variable static est-elle partagée entre plusieurs EA ?

Non. Chaque instance d’EA a sa propre mémoire. Pour partager une valeur entre programmes, il faut passer par les variables globales du terminal ou par un fichier.

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.