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

MQL4 · Indicateurs

Buffers d’indicateur en MQL4 : déclarer, styliser et masquer

Les buffers contiennent les valeurs d’un indicateur MQL4. SetIndexBuffer, IndicatorBuffers, SetIndexStyle, flèches, valeurs vides, buffers de calcul cachés et lecture depuis un EA, avec un exemple complet.

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

Un buffer d’indicateur est un tableau de double dont chaque élément correspond à une bougie du graphique. C’est lui que le terminal dessine, que la fenêtre des données affiche et qu’un Expert Advisor lit avec iCustom(). En MQL4, un buffer se déclare comme un tableau dynamique global, puis s’associe à un index avec SetIndexBuffer() ; son affichage se règle avec SetIndexStyle() et les fonctions voisines. Cette page détaille ces fonctions, la différence entre buffers affichés et buffers de calcul, le traitement des valeurs vides et la construction d’un indicateur de flèches, cas typique où ces notions comptent.

Déclarer et relier un buffer

#property indicator_buffers 2       // nombre de buffers affichés

double BufLigne[];                  // tableau dynamique, sans taille
double BufFleches[];

int OnInit()
{
   SetIndexBuffer(0, BufLigne);     // le buffer d'index 0 est BufLigne
   SetIndexBuffer(1, BufFleches);
   return(INIT_SUCCEEDED);
}

Le tableau est déclaré sans taille : c’est le terminal qui l’agrandit à mesure que de nouvelles bougies arrivent. SetIndexBuffer() renvoie un booléen ; il échoue notamment si l’index dépasse le nombre de buffers déclarés. Comme pour les séries de prix, l’élément 0 d’un buffer MQL4 correspond à la bougie la plus récente : BufLigne[1] est la valeur de la dernière bougie clôturée, au même titre que Close[1] ; cette convention est expliquée dans [Tableaux de séries (Close[], Time[])](/mql4/bases/tableaux-de-series/).

Buffers affichés et buffers de calcul

La directive #property indicator_buffers fixe le nombre de buffers affichés. Un indicateur a souvent besoin de séries intermédiaires qui ne doivent pas apparaître sur le graphique : une moyenne utilisée dans le calcul, une valeur brute avant lissage. Pour ces séries, la fonction IndicatorBuffers() déclare le nombre total de buffers, affichés et cachés. Les buffers cachés prennent les index suivant les buffers affichés.

#property indicator_buffers 1      // un seul tracé visible

double BufSignal[];                // index 0 : affiché
double BufBrut[];                  // index 1 : calcul seulement

int OnInit()
{
   IndicatorBuffers(2);            // 2 buffers au total
   SetIndexBuffer(0, BufSignal);
   SetIndexBuffer(1, BufBrut);
   SetIndexStyle(1, DRAW_NONE);    // jamais dessiné
   SetIndexLabel(1, NULL);         // absent de la fenêtre des données
   return(INIT_SUCCEEDED);
}

Pourquoi utiliser un buffer plutôt qu’un tableau global ordinaire ? Parce que le terminal gère sa taille et son décalage à chaque nouvelle bougie : la valeur de la bougie qui vient de se clôturer passe automatiquement de l’index 0 à l’index 1. Avec un tableau ordinaire, vous devriez gérer ce décalage vous-même.

Régler l’affichage : SetIndexStyle et ses voisines

SetIndexStyle(int index, int type, int style, int width, color clr) fixe le type de tracé ; les trois derniers paramètres sont facultatifs. Les types les plus courants sont :

TypeUsage
DRAW_LINEcourbe continue (moyennes, canaux)
DRAW_HISTOGRAMbarres verticales depuis zéro, typiquement en sous-fenêtre
DRAW_ARROWun symbole sur chaque bougie ayant une valeur
DRAW_SECTIONsegments reliant les seules valeurs non vides
DRAW_NONErien n’est dessiné (buffer de calcul)

D’autres fonctions complètent le réglage :

  • SetIndexLabel(index, texte) donne le nom affiché dans la fenêtre des données ; avec NULL, le buffer n’y apparaît pas ;
  • SetIndexDrawBegin(index, n) ne commence le tracé qu’à partir de la n-ième bougie depuis le début de l’historique, ce qui masque la zone où l’indicateur n’a pas encore assez de données ;
  • SetIndexEmptyValue(index, valeur) définit la valeur considérée comme vide, EMPTY_VALUE par défaut ;
  • SetIndexArrow(index, code) choisit le symbole d’un tracé DRAW_ARROW, parmi les caractères de la police Wingdings ; les codes 233 et 234 donnent des flèches vers le haut et vers le bas ;
  • SetIndexShift(index, n) décale le tracé de n bougies vers la droite (ou vers la gauche si n est négatif), comme le fait l’Ichimoku pour son nuage.

Les valeurs vides

Sur une bougie où un buffer ne doit rien afficher, il doit contenir sa valeur vide. Par défaut, c’est EMPTY_VALUE, que le terminal ne dessine pas et que la fenêtre des données n’affiche pas. Ce point est crucial pour les indicateurs de flèches : un buffer laissé à 0 sur les bougies sans signal dessinerait une flèche au niveau de prix zéro, et un EA qui le lit verrait 0 au lieu d’une absence de signal.

Deux règles simples évitent les problèmes. D’abord, écrivez explicitement la valeur vide sur chaque bougie recalculée qui n’a pas de signal, car un buffer recalculé peut contenir l’ancienne valeur d’une flèche qui n’est plus justifiée. Ensuite, si vous choisissez une autre valeur vide avec SetIndexEmptyValue(), documentez-la en commentaire pour les EA qui liront l’indicateur avec iCustom en MQL4.

Exemple complet : indicateur de flèches sur croisement

L’indicateur suivant dessine une flèche sous la bougie quand la clôture repasse au-dessus d’une moyenne mobile, et au-dessus quand elle repasse en dessous. La moyenne est calculée dans un buffer caché, la flèche est placée sur la bougie qui confirme le croisement.

#property strict
#property indicator_chart_window
#property indicator_buffers 2
#property indicator_color1  clrLimeGreen
#property indicator_color2  clrTomato

input int Periode = 50;

double BufAchat[], BufVente[];     // index 0 et 1 : affichés
double BufMoyenne[];               // index 2 : calcul

int OnInit()
{
   IndicatorBuffers(3);
   SetIndexBuffer(0, BufAchat);
   SetIndexBuffer(1, BufVente);
   SetIndexBuffer(2, BufMoyenne);

   SetIndexStyle(0, DRAW_ARROW);  SetIndexArrow(0, 233);   // flèche vers le haut
   SetIndexStyle(1, DRAW_ARROW);  SetIndexArrow(1, 234);   // flèche vers le bas
   SetIndexStyle(2, DRAW_NONE);
   SetIndexLabel(0, "Achat");
   SetIndexLabel(1, "Vente");
   SetIndexLabel(2, NULL);
   SetIndexEmptyValue(0, EMPTY_VALUE);
   SetIndexEmptyValue(1, EMPTY_VALUE);
   return(INIT_SUCCEEDED);
}

int OnCalculate(const int rates_total, const int prev_calculated,
                const datetime &time[], const double &open[], const double &high[],
                const double &low[], const double &close[], const long &tick_volume[],
                const long &volume[], const int &spread[])
{
   if(rates_total <= Periode + 2) return(0);
   int limite = (prev_calculated == 0) ? rates_total - Periode - 1
                                       : rates_total - prev_calculated + 1;

   // 1. Moyenne dans le buffer caché
   for(int i = limite - 1; i >= 0; i--)
      BufMoyenne[i] = iMA(NULL, 0, Periode, 0, MODE_SMA, PRICE_CLOSE, i);

   // 2. Flèches : la valeur vide est écrite explicitement sur chaque bougie traitée
   int debut = MathMin(limite, rates_total - Periode - 2);
   for(int i = debut - 1; i >= 0; i--)
   {
      BufAchat[i] = EMPTY_VALUE;
      BufVente[i] = EMPTY_VALUE;
      if(Close[i + 1] <= BufMoyenne[i + 1] && Close[i] > BufMoyenne[i])
         BufAchat[i] = Low[i] - 10 * Point;          // flèche sous la bougie
      else if(Close[i + 1] >= BufMoyenne[i + 1] && Close[i] < BufMoyenne[i])
         BufVente[i] = High[i] + 10 * Point;         // flèche au-dessus
   }
   return(rates_total);
}

Sur la bougie 0, la flèche peut apparaître puis disparaître au gré des ticks, puisque la clôture n’est pas définitive : c’est pour cela que chaque bougie recalculée repart d’une valeur vide. Un EA qui lit cet indicateur doit donc consulter le shift 1 : iCustom(NULL, 0, "FlechesMA", 50, 0, 1) renvoie le niveau de la flèche d’achat sur la dernière bougie clôturée, ou EMPTY_VALUE s’il n’y en a pas.

Choisir entre un buffer de calcul et iMAOnArray

Pour lisser une série intermédiaire, deux approches existent en MQL4. La première consiste à stocker la série dans un buffer caché puis à appeler iMAOnArray() sur ce buffer : c’est concis, mais la fonction recalcule la moyenne sur la fenêtre demandée à chaque appel. La seconde consiste à calculer le lissage vous-même dans un second buffer caché, bougie par bougie, en profitant du recalcul incrémental : c’est un peu plus long à écrire mais plus économe, surtout pour une moyenne exponentielle qui ne dépend que de la valeur précédente. Pour un indicateur destiné à être appelé par un EA en optimisation, la seconde approche est généralement préférable.

Dans les deux cas, conservez les séries intermédiaires dans des buffers plutôt que dans des tableaux ordinaires : le terminal les décale automatiquement à l’arrivée de chaque nouvelle bougie, et vous pouvez les rendre visibles temporairement, le temps de vérifier vos calculs, en changeant simplement leur style de DRAW_NONE à DRAW_LINE.

Pièges fréquents

  • Oublier IndicatorBuffers() : déclarer trois buffers avec SetIndexBuffer() alors que seuls deux sont prévus provoque l’échec de la liaison du troisième ; le buffer de calcul reste vide et le résultat est faux.
  • Confondre la numérotation : indicator_color1 s’applique au buffer 0. Les directives #property comptent à partir de 1, les fonctions à partir de 0.
  • Flèches fantômes : sans remise à la valeur vide, une flèche reste affichée sur une bougie où le croisement a été annulé avant la clôture.
  • Trop de buffers pour un EA : la documentation de iCustom() indique des index de 0 à 7. Placez les valeurs utiles à un robot dans les premiers buffers.

Pour la structure générale d’un indicateur, voir Créer un indicateur en MQL4 ; pour l’équivalent sur MetaTrader 5, Buffers et styles de tracé en MQL5. Toutes les pages de la rubrique sont listées dans Indicateurs en MQL4.

FAQ

Quelle différence entre indicator_buffers et IndicatorBuffers() ?

La directive #property indicator_buffers fixe le nombre de buffers affichés. La fonction IndicatorBuffers(), appelée dans OnInit(), fixe le nombre total de buffers, y compris les buffers de calcul non affichés.

Comment cacher un buffer de la fenêtre des données ?

Appelez SetIndexLabel(index, NULL). Pour qu’il ne soit pas non plus dessiné, réglez son style avec SetIndexStyle(index, DRAW_NONE).

Pourquoi mes flèches apparaissent au niveau zéro ?

Le buffer contient 0 au lieu de la valeur vide sur les bougies sans signal. Écrivez EMPTY_VALUE sur ces bougies, ou déclarez 0 comme valeur vide avec SetIndexEmptyValue(index, 0.0).

Quels codes utiliser avec SetIndexArrow ?

Les codes correspondent aux caractères de la police Wingdings. Les codes 233 et 234 sont souvent utilisés pour des flèches vers le haut et vers le bas ; affichez quelques codes sur un graphique pour choisir le symbole qui vous convient.

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.