MQL5 · Bases du langage
Énumérations en MQL5 : créer et utiliser ses propres enum
Créer des énumérations MQL5 pour remplacer les valeurs magiques et proposer des listes déroulantes dans les paramètres : syntaxe, numérotation, EnumToString, switch et pièges de maintenance.
Une énumération (enum) définit un type dont les valeurs possibles sont une liste fermée de constantes nommées : enum ENUM_SENS { SENS_ACHAT, SENS_VENTE, SENS_LES_DEUX };. Sans valeur explicite, le premier membre vaut 0 et chaque membre suivant vaut le précédent plus un. En MQL5, une énumération occupe toujours 4 octets et se comporte comme un entier. Son principal intérêt dans un Expert Advisor est double : rendre le code lisible (if(sens == SENS_ACHAT) au lieu de if(sens == 0)) et proposer à l’utilisateur une liste déroulante dans les paramètres, au lieu d’un champ numérique où il peut saisir n’importe quoi.
Cette page fait partie de la rubrique Les bases du langage MQL5.
Syntaxe et valeurs
La forme générale documentée est enum nom { liste de valeurs };, la liste étant constituée d’identifiants séparés par des virgules. Les règles de numérotation sont les suivantes :
- si le premier membre n’a pas de valeur, il vaut 0 ;
- chaque membre sans valeur explicite vaut la valeur du membre précédent plus un ;
- on peut affecter une valeur à n’importe quel membre, et la numérotation reprend à partir de là.
L’exemple de la documentation l’illustre : dans une énumération où month = 1, puis two_months, quarter, puis halfyear = 6 et year = 12, les membres non affectés valent 2 et 3.
Deux différences avec le C++ sont signalées explicitement par la documentation. D’une part, la taille d’une énumération MQL5 est toujours de 4 octets, et sizeof renvoie 4. D’autre part, on ne peut pas déclarer d’énumération anonyme : un nom est obligatoire après enum.
Conventions de nommage
Les énumérations intégrées de MQL5 suivent une convention cohérente : un nom de type en majuscules préfixé par ENUM_ (ENUM_TIMEFRAMES, ENUM_ORDER_TYPE) et des membres en majuscules partageant un préfixe commun (ORDER_TYPE_BUY, ORDER_TYPE_SELL). Adopter la même convention pour vos énumérations les rend immédiatement reconnaissables et évite les collisions de noms, car les membres d’une énumération sont visibles dans toute la portée où elle est déclarée.
Les énumérations intégrées
Vous utilisez des énumérations dès vos premières lignes de MQL5, souvent sans y penser. Quelques exemples courants :
| Énumération | Usage | Exemples de valeurs |
|---|---|---|
| ENUM_TIMEFRAMES | Unité de temps | PERIOD_M15, PERIOD_H1, PERIOD_D1 |
| ENUM_MA_METHOD | Méthode de moyenne mobile | MODE_SMA, MODE_EMA |
| ENUM_APPLIED_PRICE | Prix utilisé par un indicateur | PRICE_CLOSE, PRICE_TYPICAL |
| ENUM_ORDER_TYPE | Type d’ordre | ORDER_TYPE_BUY, ORDER_TYPE_SELL_LIMIT |
| ENUM_POSITION_TYPE | Sens d’une position | POSITION_TYPE_BUY, POSITION_TYPE_SELL |
| ENUM_INIT_RETCODE | Résultat de OnInit | INIT_SUCCEEDED, INIT_FAILED |
Ces types peuvent servir directement de type à un paramètre input : input ENUM_TIMEFRAMES InpTF = PERIOD_H1; affiche la liste des unités de temps dans la fenêtre des paramètres.
Énumérations et paramètres input
C’est l’usage le plus visible. Lorsqu’un paramètre input est d’un type énuméré, chaque membre apparaît dans une liste déroulante. La documentation des variables d’entrée précise que le commentaire placé après chaque membre remplace son nom technique dans cette liste. Vous pouvez donc écrire des identifiants courts dans le code et des libellés explicites pour l’utilisateur.
Dans le Strategy Tester, un paramètre énuméré peut être optimisé comme un entier : le testeur parcourt les valeurs de la liste. C’est une façon élégante de comparer plusieurs variantes d’une même logique (type de stop, méthode de sortie, filtre de tendance) au sein d’une même optimisation. Les paramètres d’entrée sont présentés en détail dans Paramètres input et sinput.
Énumérations et switch
Comme une énumération est un entier, elle est le compagnon naturel de l’instruction switch : chaque case correspond à un membre. Le code se lit comme une table de décision, et l’ajout d’un nouveau membre se traite en ajoutant un case. Prévoyez toujours un default qui journalise une valeur inattendue, par exemple si un entier mal converti a été affecté à la variable. Le fonctionnement de switch est expliqué dans Conditions if, else et switch.
Convertir une énumération
Trois conversions reviennent souvent :
- vers un entier : implicite ;
int v = SENS_VENTE;donne la valeur numérique du membre ; - depuis un entier : explicite, avec une conversion de type ; c’est indispensable pour lire certaines propriétés, car
PositionGetInteger(POSITION_TYPE)renvoie unlongque l’on convertit en(ENUM_POSITION_TYPE); - vers une chaîne :
EnumToString(valeur)renvoie le nom du membre, par exemple"ORDER_TYPE_BUY". Selon la documentation, une valeur qui ne correspond à aucun membre produit une chaîne du typeENUM_ORDER_TYPE::-1.
Rien n’empêche, par une conversion explicite, d’affecter à une variable énumérée un entier qui ne correspond à aucun membre. Le compilateur ne le vérifie pas : d’où l’intérêt du default défensif.
Exemple complet : choisir le type de stop par une liste déroulante
//+------------------------------------------------------------------+
//| EA : enumeration personnalisee en parametre, switch et conversion|
//+------------------------------------------------------------------+
enum ENUM_TYPE_STOP
{
STOP_FIXE = 0, // Stop fixe en points
STOP_ATR = 1, // Stop proportionnel a l'ATR
STOP_EXTREME = 2 // Stop sous le dernier plus bas / plus haut
};
enum ENUM_SENS
{
SENS_ACHAT, // Achats uniquement (vaut 0)
SENS_VENTE, // Ventes uniquement (vaut 1)
SENS_LES_DEUX // Achats et ventes (vaut 2)
};
input ENUM_TYPE_STOP InpTypeStop = STOP_ATR; // Type de stop
input ENUM_SENS InpSens = SENS_LES_DEUX; // Sens autorise
input int InpStopPts = 300; // Stop fixe (points)
input double InpMultATR = 2.0; // Multiplicateur ATR
//--- Distance de stop en prix selon le type choisi
double DistanceStop(double atr, double extreme, double prixEntree)
{
switch(InpTypeStop)
{
case STOP_FIXE:
return(InpStopPts * _Point);
case STOP_ATR:
return(InpMultATR * atr);
case STOP_EXTREME:
return(MathAbs(prixEntree - extreme));
default:
PrintFormat("Type de stop inattendu : %s", EnumToString(InpTypeStop));
return(0.0);
}
}
bool AchatAutorise() { return(InpSens == SENS_ACHAT || InpSens == SENS_LES_DEUX); }
bool VenteAutorisee() { return(InpSens == SENS_VENTE || InpSens == SENS_LES_DEUX); }
int OnInit()
{
PrintFormat("Stop : %s (valeur %d), sens : %s, taille d'une enum : %d octets",
EnumToString(InpTypeStop), (int)InpTypeStop,
EnumToString(InpSens), sizeof(ENUM_SENS));
return(INIT_SUCCEEDED);
}
void OnTick()
{
// Lecture du sens d'une position existante : conversion explicite long -> enum
if(PositionSelect(_Symbol))
{
ENUM_POSITION_TYPE type = (ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);
if(type == POSITION_TYPE_BUY && !AchatAutorise())
Print("Position d'achat ouverte alors que les achats sont desactives");
}
double dist = DistanceStop(0.0015, 1.0800, 1.0850); // valeurs d'exemple
if(dist <= 0.0)
return;
}
L’utilisateur voit dans les paramètres « Stop proportionnel a l’ATR » plutôt que STOP_ATR, et ne peut choisir qu’une des trois options prévues. Le code, lui, reste lisible : aucune valeur magique 0, 1 ou 2 n’apparaît dans les conditions.
Énumération, constantes ou booléens ?
Trois outils permettent de représenter un choix, et chacun a sa place. Un bool suffit pour un choix binaire stable (« activer le filtre de spread »). Des constantes #define ou const int conviennent pour des valeurs numériques indépendantes, sans lien entre elles. Une énumération s’impose dès qu’il existe plusieurs options mutuellement exclusives : elle crée un type à part entière, que le compilateur distingue des autres entiers, et elle documente dans le code la liste complète des possibilités. Un bon indice : si vous êtes tenté d’écrire deux booléens qui ne doivent jamais être vrais en même temps (« achats seulement » et « ventes seulement »), remplacez-les par une énumération à trois membres, comme ENUM_SENS dans l’exemple ci-dessus. Vous supprimez ainsi toute une catégorie de configurations incohérentes.
Pièges fréquents
- Changer l’ordre des membres : si aucune valeur n’est explicite, insérer un membre au milieu décale tous les suivants. Les jeux de paramètres sauvegardés (fichiers
.set) et les résultats d’optimisation pointent alors vers d’autres options. Donnez des valeurs explicites aux énumérations utilisées en paramètre. - Comparer à un nombre :
if(InpTypeStop == 1)fonctionne mais annule tout l’intérêt de l’énumération. Comparez au membre. - Énumération anonyme : refusée par le compilateur MQL5, contrairement au C++.
- Collision de noms : deux énumérations qui contiennent un membre
NONEentrent en conflit. Préfixez les membres. - Trop de membres en paramètre : la documentation indique que le nombre de valeurs d’une énumération utilisée en paramètre est limité ; une liste très longue est de toute façon peu ergonomique.
Les énumérations sont souvent déclarées dans un fichier .mqh commun à plusieurs robots, inclus avec #include : voir #include, #define et #property. Dans les fonctions de trading, vous les retrouverez partout, par exemple dans Ordres limites et stop.
FAQ
Quelle est la valeur du premier membre d’une enum en MQL5 ?
Zéro, si aucune valeur n’est indiquée. Chaque membre suivant sans valeur explicite vaut le précédent plus un. Vous pouvez fixer n’importe quel membre avec le signe égal.
Comment afficher le nom d’une valeur d’énumération ?
Utilisez EnumToString(valeur), qui renvoie le nom du membre sous forme de chaîne, par exemple ORDER_TYPE_BUY. C’est très utile dans les messages du journal.
Comment convertir un long en ENUM_POSITION_TYPE ?
Par une conversion explicite : (ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE). Les fonctions de propriétés renvoient des entiers génériques ; la conversion rend le code lisible et permet la comparaison avec les membres.
Peut-on optimiser un paramètre de type enum dans le Strategy Tester ?
Oui. Le testeur fait varier la valeur parmi les membres de l’énumération, ce qui permet de comparer plusieurs variantes d’une logique dans une même optimisation. Donnez des valeurs explicites aux membres pour que les résultats restent interprétables si vous modifiez la liste.
- Types de données en MQL5
- Variables, constantes et portée
- 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
- #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
