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

MQL5 · Bases du langage

Opérateurs et expressions en MQL5 : arithmétique, logique, priorités

Arithmétique, comparaisons, opérateurs logiques, bit à bit et ternaire : comment MQL5 évalue une expression, dans quel ordre, et quels réflexes adopter pour écrire des conditions de trading fiables.

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

Une expression MQL5 combine des opérandes (variables, constantes, appels de fonction) avec des opérateurs : arithmétiques (+ - * / %), de comparaison (== != < > <= >=), logiques (&& || !), d’affectation (= += -=…), bit à bit (& | ^ ~ << >>) et l’opérateur conditionnel ?:. MQL5 suit les règles de priorité du C++, et la documentation précise qu’elles diffèrent de celles de MQL4. Trois points font l’essentiel des bugs : la priorité des opérateurs, la division entière et l’évaluation en court-circuit de && et ||.

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

Opérateurs arithmétiques

Les opérateurs arithmétiques sont l’addition +, la soustraction -, le changement de signe, la multiplication *, la division / et le reste de la division %. L’exemple de la documentation pour le reste est parlant : minutes = time % 60;. En trading, % sert par exemple à agir toutes les N bougies ou à extraire les minutes d’un nombre de secondes.

La division mérite une vigilance constante. Quand les deux opérandes sont des entiers, le résultat est entier : int i = 1/2; vaut 0, et double x = 1/2; vaut aussi 0, car l’expression est calculée en entier avant d’être stockée. Il suffit qu’un opérande soit réel (1.0/2) pour obtenir 0,5. Ce comportement est détaillé dans Types de données en MQL5.

Une division par zéro provoque une erreur d’exécution critique qui arrête le programme. Avant de diviser par une valeur calculée (une ATR, un écart de prix, une valeur de tick), vérifiez qu’elle n’est pas nulle. Le diagnostic de cette erreur est traité dans Division par zéro.

Incrémentation et décrémentation

++ et -- ajoutent ou retirent 1. En forme préfixe (++i), la variable est modifiée avant d’être utilisée dans l’expression ; en forme postfixe (i++), après. La documentation précise que ces opérateurs ne s’appliquent qu’aux variables, pas aux constantes. Elle met aussi en garde contre des expressions comme int k = i++ + ++i;, dont le résultat dépend de l’ordre d’évaluation retenu par le compilateur, et recommande explicitement de ne pas s’y fier. Règle pratique : n’utilisez ++ et -- que dans des instructions isolées ou dans la troisième partie d’une boucle for.

Opérateurs de comparaison

Les comparaisons renvoient true ou false : égal ==, différent !=, inférieur <, supérieur >, inférieur ou égal <=, supérieur ou égal >=. Sur des entiers, elles sont exactes. Sur des double, l’égalité stricte est à proscrire : la documentation conseille de comparer l’écart avec une tolérance ou de normaliser la différence. Comparer Ask >= niveau pour déclencher une entrée est acceptable ; tester Ask == niveau ne l’est pas.

Ne confondez pas = (affectation) et == (comparaison). Écrire if(signal = 1) affecte 1 à signal puis teste la valeur affectée, qui est toujours vraie.

Opérateurs logiques et évaluation en court-circuit

&& (ET) renvoie vrai si les deux opérandes sont non nuls, || (OU) si au moins l’un l’est, et ! (NON) inverse un opérande. La documentation confirme que MQL5 pratique l’évaluation en court-circuit : le calcul s’arrête dès que le résultat est certain. Dans A && B, B n’est pas évalué si A est faux ; dans A || B, B n’est pas évalué si A est vrai.

Cette propriété est précieuse dans un EA. Placez à gauche les tests rapides et les gardes de sécurité, à droite les appels coûteux ou risqués :

  • if(PositionsTotal() == 0 && SignalAchat()) n’appelle la fonction de signal que si aucune position n’est ouverte ;
  • if(atr > 0.0 && distance / atr > 2.0) ne divise que si l’ATR est positive ;
  • if(i < ArraySize(tab) && tab[i] > seuil) évite un accès hors limites.

Affectation et affectations composées

L’opérateur = copie la valeur de droite dans la variable de gauche. Les formes composées combinent une opération et une affectation : +=, -=, *=, /=, %=, <<=, >>=, &=, |=, ^=. Ainsi profitTotal += profitTrade; équivaut à profitTotal = profitTotal + profitTrade;. L’affectation est associative de droite à gauche.

Opérateurs bit à bit

&, |, ^, ~, << et >> travaillent sur les bits des entiers. Ils sont moins courants dans un EA, mais indispensables pour lire des propriétés codées sous forme de drapeaux. Par exemple, les modes de remplissage autorisés d’un symbole (SYMBOL_FILLING_MODE) sont une combinaison de bits que l’on teste avec &. De même, le champ flags d’un MqlTick se teste avec TICK_FLAG_BID ou TICK_FLAG_ASK. Attention à la priorité : & est moins prioritaire que ==, il faut donc écrire (flags & TICK_FLAG_BID) != 0 avec des parenthèses.

L’opérateur conditionnel ?:

condition ? valeur1 : valeur2 renvoie la première valeur si la condition est vraie, la seconde sinon. La documentation impose que les deux expressions soient du même type et non void. Il est idéal pour des affectations courtes : string sens = (type == POSITION_TYPE_BUY) ? "achat" : "vente";. Au-delà d’une condition simple, préférez un if ou un switch, présentés dans Conditions if, else et switch.

Priorité et associativité

Le tableau suivant reprend l’ordre de priorité de la documentation officielle, du plus prioritaire au moins prioritaire.

PrioritéOpérateursAssociativité
1() [] .gauche à droite
2! ~ - (signe) ++ -- (type) sizeofdroite à gauche
3* / %gauche à droite
4+ -gauche à droite
5<< >>gauche à droite
6< <= > >=gauche à droite
7== !=gauche à droite
8&gauche à droite
9^gauche à droite
10OU bit à bit (barre verticale simple)gauche à droite
11&&gauche à droite
12OU logique (double barre verticale)gauche à droite
13?:droite à gauche
14= et affectations composéesdroite à gauche
15,gauche à droite

Une conséquence directe : && est plus prioritaire que ||. L’expression a || b && c se lit a || (b && c). Dans une condition d’entrée combinant plusieurs filtres, ajoutez des parenthèses même lorsqu’elles ne sont pas nécessaires : elles documentent votre intention.

Exemple complet : calculs d’un signal et d’un stop

//+------------------------------------------------------------------+
//| Script : operateurs appliques a un calcul de trading             |
//+------------------------------------------------------------------+
void OnStart()
  {
   double ask    = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
   double bid    = SymbolInfoDouble(_Symbol, SYMBOL_BID);
   int    spread = (int)SymbolInfoInteger(_Symbol, SYMBOL_SPREAD);   // en points

   // Arithmetique : spread recalcule a partir des prix (division reelle)
   double spreadCalc = (ask - bid) / _Point;

   // Reste de division : une action toutes les 4 barres
   int  nbBarres     = Bars(_Symbol, _Period);
   bool barreMultiple = (nbBarres % 4 == 0);

   // Court-circuit : la division n'a lieu que si le diviseur est positif
   double atr      = 0.0012;              // valeur d'exemple
   double distance = 0.0030;
   bool   loin     = (atr > 0.0 && distance / atr > 2.0);

   // Priorite : parentheses explicites autour de chaque bloc logique
   bool spreadOk = (spread <= 20);
   bool entree   = (spreadOk && loin) || (barreMultiple && !loin);

   // Operateur conditionnel et affectation composee
   double stopPts = 250;
   stopPts += (spread > 15) ? spread : 0;   // elargir le stop si spread eleve
   double stopPrix = ask - stopPts * _Point;

   // Bit a bit : test d'un drapeau de mode de remplissage
   long filling = SymbolInfoInteger(_Symbol, SYMBOL_FILLING_MODE);
   bool iocOk   = ((filling & SYMBOL_FILLING_IOC) != 0);

   PrintFormat("Spread %d pts (calcule %.1f) | entree=%s | stop=%.*f | IOC=%s",
               spread, spreadCalc, entree ? "oui" : "non",
               _Digits, stopPrix, iocOk ? "oui" : "non");
  }

Méthode pour relire une expression complexe

Face à une condition d’entrée de plusieurs lignes, une méthode simple consiste à la découper. Calculez chaque sous-condition dans une variable bool au nom explicite (tendanceHaussiere, spreadAcceptable, horaireValide), puis combinez ces variables sur une seule ligne. Le code devient lisible, chaque élément peut être affiché dans le journal pendant le débogage, et les erreurs de priorité disparaissent puisque chaque bloc est déjà évalué. Le léger coût de cette approche est la perte du court-circuit entre les blocs : si l’un d’eux appelle une fonction coûteuse, gardez-le dans l’expression finale, à droite d’un &&.

Pièges fréquents

  • = au lieu de == dans une condition : l’affectation est toujours exécutée.
  • Division entière sur des paramètres int : convertissez avant de diviser.
  • Comparaison stricte de prix : utilisez une tolérance.
  • Oubli de parenthèses autour d’un test bit à bit ou d’un mélange &&/||.
  • Expressions à effets de bord combinant plusieurs ++ : résultat non garanti.
  • Ordre des tests : placez les gardes (diviseur non nul, index valide) avant le test qui en dépend, pour profiter du court-circuit.

Les opérateurs se retrouvent ensuite dans toutes les structures de contrôle, à commencer par les boucles for, while et do while.

FAQ

MQL5 évalue-t-il toujours les deux côtés d’un && ?

Non. La documentation confirme l’évaluation en court-circuit : si l’opérande gauche d’un && est faux, l’opérande droit n’est pas évalué ; pour le OU logique, il ne l’est pas si l’opérande gauche est vrai.

Pourquoi 7/2 donne 3 en MQL5 ?

Parce que les deux opérandes sont des entiers : la division est entière et la partie décimale est perdue. Écrivez 7.0/2 ou (double)7/2 pour obtenir 3,5.

Les priorités sont-elles identiques à MQL4 ?

Non. La documentation indique que MQL5 suit les priorités du C++, qui diffèrent de celles de MQL4. Lors d’une migration, ajoutez des parenthèses explicites dans les expressions complexes.

Quand utiliser l’opérateur ternaire plutôt qu’un if ?

Pour une affectation simple qui dépend d’une seule condition, comme choisir un libellé ou un sens. Dès que la logique comporte plusieurs branches ou des effets de bord, un if ou un switch reste plus lisible.

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.