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.
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écanisme | Nature | Usage typique |
|---|---|---|
| const | Variable typée en lecture seule | Constante de calcul : const double PIP_FACTOR = 10.0; |
| #define | Substitution de texte avant compilation | Taille de tableau, drapeau de compilation |
| input | Paramètre externe réglable par l’utilisateur | Pé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 deifpeut 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
staticsont réinitialisées avec le programme. Ne comptez pas sur elles pour mémoriser durablement un nombre de trades. - Masquage de nom : une locale
lotqui masque une globalelotdonne 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.
- Types de données en MQL5
- Paramètres input et sinput
- Opérateurs et expressions
- Conditions if, else et switch
- Boucles for, while et do while
- Écrire ses propres fonctions
- Tableaux statiques et dynamiques
- ArraySetAsSeries et indexation des séries
- Manipuler les chaînes de caractères
- Dates, heures et fuseaux
- Structures (struct) et MqlRates, MqlTick
- Énumérations (enum) personnalisées
- #include, #define et #property
- Les fonctions événementielles
- Print, Comment, Alert : déboguer avec le journal
- NormalizeDouble et précision des prix
- SymbolInfoDouble, SymbolInfoInteger
- AccountInfoDouble : lire les informations du compte
- Bien utiliser MetaEditor
