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

MQL5 · Bases du langage

Écrire ses propres fonctions en MQL5 : paramètres, retour, références

Découper un Expert Advisor en fonctions claires : déclaration, valeur de retour, passage par valeur ou par référence, const, paramètres par défaut et surcharge, avec un exemple d’EA structuré.

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

Une fonction MQL5 regroupe des instructions sous un nom réutilisable : type_retour Nom(paramètres) { corps }. Elle reçoit des valeurs en paramètres, effectue un traitement et renvoie éventuellement un résultat avec return. Les paramètres sont passés par valeur (copie) par défaut, ou par référence avec & lorsque la fonction doit modifier la variable de l’appelant ; la documentation précise que les tableaux, les structures et les objets sont toujours passés par référence. Découper un Expert Advisor en petites fonctions nommées (SignalAchat(), CalculerLot(), FermerTout()) est le moyen le plus sûr de le rendre lisible, testable et réutilisable.

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

Déclarer une fonction

Une définition comporte quatre éléments : le type de la valeur renvoyée, le nom, la liste des paramètres entre parenthèses et le corps entre accolades. Une fonction qui ne renvoie rien est déclarée void. Une fonction qui renvoie une valeur doit exécuter un return valeur; sur tous les chemins possibles ; le compilateur signale les chemins qui n’en ont pas.

Les fonctions événementielles comme OnInit(), OnTick() ou OnDeinit() sont des fonctions comme les autres, à ceci près que le terminal les appelle lui-même. Leur nom, leur type de retour et leurs paramètres doivent correspondre exactement à la documentation, faute de quoi elles ne sont pas reconnues comme gestionnaires. Elles sont décrites dans Les fonctions événementielles.

Le nom d’une fonction doit décrire ce qu’elle fait. Un verbe pour une action (OuvrirAchat), une question pour un test booléen (EstNouvelleBougie, SpreadAcceptable), un nom pour un calcul (DistanceStop).

Passage par valeur et par référence

Par défaut, un paramètre reçoit une copie de l’argument : modifier le paramètre dans la fonction n’a aucun effet sur la variable de l’appelant. Pour que la fonction agisse sur la variable d’origine, on ajoute & après le type : void Ajuster(double &lot). La documentation résume la règle : MQL5 utilise les deux méthodes, avec une exception, les tableaux, les variables de type structure et les objets de classe sont toujours passés par référence.

Le passage par référence sert aussi à renvoyer plusieurs résultats. Le schéma courant en MQL5, utilisé par de nombreuses fonctions intégrées comme SymbolInfoTick(), consiste à renvoyer un bool indiquant la réussite et à remplir les résultats dans des paramètres par référence.

Le mot-clé const sur les paramètres

Comme un tableau ou une structure est toujours transmis par référence, la fonction pourrait le modifier par erreur. Déclarer le paramètre const (double Moyenne(const double &prix[])) interdit toute modification : le compilateur renvoie une erreur en cas de tentative. C’est une documentation gratuite et une protection pour toutes les fonctions qui se contentent de lire.

Paramètres par défaut

Un paramètre peut recevoir une valeur par défaut dans la déclaration : double CalculerLot(double risquePct, int stopPts, double lotMax = 10.0). À l’appel, on peut alors omettre les arguments finaux. La documentation précise deux règles : la liste des arguments peut être raccourcie, mais pas avant le premier paramètre par défaut, et l’on ne peut pas sauter un paramètre, même s’il a une valeur par défaut. En pratique, placez les paramètres par défaut en fin de liste, du plus souvent modifié au plus rarement modifié.

Surcharge de fonctions

Plusieurs fonctions peuvent porter le même nom si elles diffèrent par le nombre ou le type de leurs paramètres. Le compilateur choisit la bonne version selon les arguments fournis, en cherchant d’abord une correspondance stricte, puis une promotion standard (par exemple float vers double), puis une conversion standard. Si plusieurs versions conviennent aussi bien, l’appel est ambigu ; la documentation conseille alors une conversion explicite. Le type de retour seul ne suffit pas à distinguer deux surcharges.

La surcharge est pratique pour offrir une version simple et une version détaillée d’un même calcul, par exemple DistancePoints(double prix1, double prix2) et DistancePoints(string symbole, double prix1, double prix2).

Variables locales et static dans une fonction

Les variables déclarées dans le corps d’une fonction sont locales : elles sont créées à chaque appel et détruites à la sortie. Une variable locale déclarée static conserve en revanche sa valeur d’un appel à l’autre. C’est utile pour mémoriser un état propre à la fonction, mais cela rend la fonction dépendante de son historique d’appels : à utiliser avec parcimonie. Ces notions sont développées dans Variables, constantes et portée.

Exemple complet : un EA découpé en fonctions

//+------------------------------------------------------------------+
//| EA structure en fonctions : lecture, calcul, decision            |
//+------------------------------------------------------------------+
input double InpRisquePct = 1.0;   // Risque par trade (%)
input int    InpStopPts   = 300;   // Stop loss (points)

//--- Renvoie true si une nouvelle bougie vient de s'ouvrir
bool EstNouvelleBougie()
  {
   static datetime derniere = 0;               // memorise entre les appels
   datetime actuelle = iTime(_Symbol, _Period, 0);
   if(actuelle == 0 || actuelle == derniere)
      return(false);
   derniere = actuelle;
   return(true);
  }

//--- Lit les prix courants : renvoie false en cas d'echec (resultats par reference)
bool LirePrix(double &bid, double &ask)
  {
   MqlTick tick;
   if(!SymbolInfoTick(_Symbol, tick))
      return(false);
   bid = tick.bid;
   ask = tick.ask;
   return(true);
  }

//--- Moyenne d'un tableau : const garantit qu'il n'est pas modifie
double Moyenne(const double &valeurs[], int nombre)
  {
   if(nombre <= 0)
      return(0.0);
   double somme = 0.0;
   for(int i = 0; i < nombre; i++)
      somme += valeurs[i];
   return(somme / nombre);
  }

//--- Lot selon le risque, avec un plafond par defaut
double CalculerLot(double risquePct, int stopPts, double lotMax = 5.0)
  {
   double solde     = AccountInfoDouble(ACCOUNT_BALANCE);
   double valeurTick = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_VALUE);
   double tailleTick = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_SIZE);
   if(stopPts <= 0 || valeurTick <= 0.0 || tailleTick <= 0.0)
      return(0.0);
   double pertePar1Lot = (stopPts * _Point / tailleTick) * valeurTick;   // perte pour 1 lot
   double lot = (solde * risquePct / 100.0) / pertePar1Lot;
   return(MathMin(lot, lotMax));               // normalisation au pas du symbole a ajouter
  }

void OnTick()
  {
   if(!EstNouvelleBougie())
      return;

   double bid = 0.0, ask = 0.0;
   if(!LirePrix(bid, ask))
      return;

   double closes[];
   int n = CopyClose(_Symbol, _Period, 1, 20, closes);   // 20 bougies cloturees
   if(n < 20)
      return;

   double moyenne = Moyenne(closes, n);
   double lot     = CalculerLot(InpRisquePct, InpStopPts);   // lotMax = 5.0 par defaut
   PrintFormat("Bid %.*f | moyenne 20 %.*f | lot brut %.3f",
               _Digits, bid, _Digits, moyenne, lot);
  }

OnTick() se lit désormais comme une suite d’étapes, chacune déléguée à une fonction au rôle unique. LirePrix() illustre le schéma « booléen de réussite + résultats par référence », Moyenne() reçoit un tableau en const, et CalculerLot() utilise un paramètre par défaut. Le lot calculé doit encore être arrondi au pas du symbole et borné par le minimum autorisé : c’est l’objet de Calculer et normaliser la taille de lot. Le principe de dimensionnement par le risque est expliqué dans Risque par trade.

Bonnes pratiques et pièges

  • Une fonction, une responsabilité : une fonction qui lit les prix, calcule le signal et envoie l’ordre est difficile à tester. Séparez lecture, décision et exécution.
  • Valeurs de retour exploitées : une fonction qui peut échouer doit le signaler (booléen, valeur sentinelle comme -1 ou 0) et l’appelant doit le vérifier.
  • Paramètres modifiés par surprise : un tableau passé à une fonction peut être modifié par elle. Déclarez const tout paramètre en lecture seule.
  • Globales cachées : une fonction qui lit et modifie des variables globales sans les recevoir en paramètres est imprévisible. Préférez des paramètres explicites.
  • Chemin sans return : une fonction non void doit renvoyer une valeur sur toutes les branches.
  • Surcharges ambiguës : deux versions trop proches (int et long) peuvent rendre un appel ambigu. Gardez des signatures nettement différentes.

Pour regrouper des fonctions dans un fichier réutilisable par plusieurs EA, utilisez un fichier .mqh inclus avec #include, présenté dans la page consacrée au préprocesseur. Au-delà, les classes de la programmation orientée objet permettent d’associer données et fonctions.

FAQ

Comment renvoyer plusieurs valeurs depuis une fonction MQL5 ?

Passez des paramètres par référence avec & : la fonction y écrit ses résultats. Le plus courant est de renvoyer un bool de réussite et de remplir les résultats par référence, comme le fait SymbolInfoTick(). Une structure renvoyée ou passée par référence est une autre option.

Un tableau passé à une fonction est-il copié ?

Non. Selon la documentation, les tableaux, les structures et les objets de classe sont toujours passés par référence. Ajoutez const devant le paramètre si la fonction ne doit pas le modifier.

Peut-on sauter un paramètre qui a une valeur par défaut ?

Non. On peut seulement omettre les derniers arguments. Pour fixer le troisième paramètre, il faut aussi fournir explicitement le deuxième, même s’il a une valeur par défaut.

Deux fonctions peuvent-elles avoir le même nom ?

Oui, si leurs listes de paramètres diffèrent par le nombre ou le type. C’est la surcharge. Le compilateur choisit la version la mieux adaptée aux arguments ; en cas d’ambiguïté, utilisez une conversion explicite.

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.