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

MQL5 · Bases du langage

Tableaux en MQL5 : statiques, dynamiques, ArrayResize et fonctions utiles

Déclarer, initialiser, redimensionner et parcourir des tableaux en MQL5 : différences entre statiques et dynamiques, ArrayResize avec réserve, tri, recherche et erreurs de dépassement à éviter.

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

Un tableau MQL5 stocke plusieurs valeurs du même type sous un seul nom, accessibles par un index qui commence à 0. Un tableau statique a une taille fixée à la déclaration (double prix[10];) ; un tableau dynamique se déclare sans taille (double prix[];) et se dimensionne pendant l’exécution avec ArrayResize(). Les tableaux dynamiques sont les plus utilisés dans un Expert Advisor, car ce sont eux que remplissent CopyClose(), CopyRates() ou CopyBuffer(). Toute lecture en dehors des bornes arrête le programme : la taille se vérifie avec ArraySize() avant chaque accès.

Cette page fait partie de la rubrique Les bases du langage MQL5. Le sens de lecture des tableaux de prix (index 0 = barre la plus récente ou la plus ancienne) est traité à part dans ArraySetAsSeries et indexation des séries.

Déclarer un tableau

La déclaration associe un type, un nom et, pour un tableau statique, une taille entre crochets. La documentation précise qu’un tableau peut avoir au maximum quatre dimensions et que seuls des entiers sont acceptés comme index. Pour un tableau dynamique multidimensionnel, seule la première dimension est libre : double matrice[][3]; déclare un tableau dont le nombre de lignes est variable et qui a toujours trois colonnes.

Un tableau peut être initialisé entre accolades : int periodes[] = {10, 20, 50, 100};. Si la taille est omise, le compilateur la déduit de la liste. Si la liste est plus courte que la taille déclarée, la documentation indique que les éléments manquants valent 0.

Tableaux statiques

Lorsque toutes les dimensions sont indiquées, le compilateur réserve la mémoire à l’avance. Un tableau statique ne peut pas être redimensionné : ArrayResize() ne le réalloue pas. La documentation précise aussi qu’on ne peut pas lui appliquer l’indexation en série. Il convient à des données de taille connue et invariable : les sept jours de la semaine, les vingt-quatre heures d’une journée, une liste fixe de symboles.

Tableaux dynamiques et ArrayResize

La signature documentée est int ArrayResize(void &array[], int new_size, int reserve_size = 0). La fonction fixe la nouvelle taille de la première dimension et renvoie le nombre total d’éléments après redimensionnement, ou -1 en cas d’échec ; dans ce dernier cas, le tableau n’est pas modifié. Il faut donc tester le résultat.

Le troisième paramètre, reserve_size, réserve de la mémoire supplémentaire. Lorsque l’on agrandit un tableau élément par élément, chaque appel peut provoquer une réallocation coûteuse. Avec une réserve, les agrandissements suivants restent dans la mémoire déjà allouée : l’exemple de la documentation passe ainsi de 2 000 réallocations à 2.

Un tableau dynamique déclaré localement est libéré automatiquement à la sortie de son bloc. ArrayFree() libère explicitement sa mémoire et ramène sa taille à zéro, ce qui est utile pour un grand tableau global dont on n’a plus besoin.

Une catégorie particulière échappe à ces règles : les buffers d’indicateurs liés par SetIndexBuffer(). Leur taille est gérée par le terminal, et la documentation précise qu’on ne peut pas les redimensionner soi-même.

Les fonctions utiles

La bibliothèque de fonctions de tableaux est riche. Voici celles que l’on rencontre le plus souvent dans un EA ou un indicateur, avec leur rôle documenté.

FonctionRôle
ArraySizeNombre total d’éléments du tableau
ArrayRangeNombre d’éléments d’une dimension donnée
ArrayResizeNouvelle taille de la première dimension
ArrayFreeLibère le tableau dynamique et ramène sa taille à zéro
ArrayInitializeAffecte la même valeur à tous les éléments d’un tableau numérique
ArrayFillRemplit une portion du tableau avec une valeur
ArrayCopyCopie tout ou partie d’un tableau dans un autre
ArraySortTrie un tableau numérique par ordre croissant sur la première dimension
ArrayMaximum / ArrayMinimumIndex de l’élément le plus grand ou le plus petit
ArrayPrintAffiche un tableau de type simple dans le journal
ArrayRemove / ArrayInsertRetire ou insère des éléments à une position

Quelques précisions issues de la documentation. ArrayCopy a pour signature int ArrayCopy(void &dst_array[], const void &src_array[], int dst_start = 0, int src_start = 0, int count = WHOLE_ARRAY). ArraySort trie toujours par ordre croissant, quel que soit le drapeau d’indexation en série. ArrayMaximum et ArrayMinimum renvoient un index, pas une valeur, et tiennent compte du sens d’indexation ; ils renvoient -1 en cas d’échec.

Les tableaux passés aux fonctions

Un tableau est toujours passé par référence : la fonction travaille sur le tableau de l’appelant, sans copie. La syntaxe du paramètre est double &valeurs[]. Si la fonction ne doit que lire, ajoutez const : const double &valeurs[]. Une fonction ne peut pas renvoyer un tableau avec return ; elle le remplit via un paramètre par référence et renvoie, par exemple, le nombre d’éléments remplis. Ce mécanisme est détaillé dans la page consacrée aux fonctions.

Exemple complet : historique glissant des résultats de trades

Le script suivant construit un tableau dynamique de résultats, calcule des statistiques simples et montre les fonctions courantes.

//+------------------------------------------------------------------+
//| Script : tableaux statiques et dynamiques                        |
//+------------------------------------------------------------------+
#define TAILLE_MAX 20                        // fenetre glissante

double g_resultats[];                        // tableau dynamique global

//--- Ajoute un resultat, en ne gardant que les TAILLE_MAX derniers
bool AjouterResultat(double profit)
  {
   int n = ArraySize(g_resultats);
   if(n >= TAILLE_MAX)
     {
      // retire le plus ancien (index 0) pour faire de la place
      if(!ArrayRemove(g_resultats, 0, 1))
         return(false);
      n--;
     }
   if(ArrayResize(g_resultats, n + 1, TAILLE_MAX) < 0)   // reserve pour eviter les reallocations
      return(false);
   g_resultats[n] = profit;
   return(true);
  }

//--- Somme d'un tableau en lecture seule
double Somme(const double &tab[])
  {
   double s = 0.0;
   int    n = ArraySize(tab);
   for(int i = 0; i < n; i++)
      s += tab[i];
   return(s);
  }

void OnStart()
  {
   // Tableau statique initialise : les elements manquants valent 0
   double profits[8] = {12.5, -8.0, 4.2, -15.3, 22.1, -3.4};

   for(int i = 0; i < ArraySize(profits); i++)
      AjouterResultat(profits[i]);

   int n = ArraySize(g_resultats);
   PrintFormat("%d resultats, somme = %.2f", n, Somme(g_resultats));

   // Index du meilleur et du pire trade
   int iMax = ArrayMaximum(g_resultats);
   int iMin = ArrayMinimum(g_resultats);
   if(iMax >= 0 && iMin >= 0)
      PrintFormat("Meilleur : %.2f (index %d) | pire : %.2f (index %d)",
                  g_resultats[iMax], iMax, g_resultats[iMin], iMin);

   // Copie puis tri croissant de la copie (l'original garde l'ordre chronologique)
   double tries[];
   ArrayCopy(tries, g_resultats);
   ArraySort(tries);
   ArrayPrint(tries, 2);

   // Matrice dynamique : nombre de lignes variable, 2 colonnes fixes
   double niveaux[][2];
   ArrayResize(niveaux, 3);
   ArrayInitialize(niveaux, 0.0);
   niveaux[0][0] = 1.0850;  niveaux[0][1] = 1.0900;
   PrintFormat("Lignes : %d, elements : %d", ArrayRange(niveaux, 0), ArraySize(niveaux));

   ArrayFree(g_resultats);                    // liberation explicite
  }

Le tableau statique profits est déclaré avec 8 éléments mais n’en reçoit que 6 : les deux derniers valent 0 et sont ajoutés eux aussi, ce qui illustre la règle d’initialisation. Dans un vrai EA, on ne garderait que les valeurs réellement issues de l’historique des transactions.

Tableaux et données de marché

Dans un EA, la plupart des tableaux ne sont pas remplis à la main mais par les fonctions de copie : CopyClose(), CopyHigh(), CopyTime(), CopyRates() pour les prix, CopyBuffer() pour les valeurs d’indicateurs. Ces fonctions reçoivent un tableau dynamique et le dimensionnent elles-mêmes selon le nombre d’éléments copiés. Elles renvoient ce nombre, ou -1 en cas d’erreur. Le schéma sûr est toujours le même : déclarer le tableau dynamique, fixer son sens d’indexation, appeler la fonction de copie, vérifier que le nombre renvoyé est suffisant, puis seulement lire les valeurs. La lecture des indicateurs suit ce schéma, comme le montre Handles d’indicateurs et CopyBuffer.

Pièges fréquents

  • Index hors limites : l’index valide va de 0 à ArraySize(tab) - 1. Une boucle i <= ArraySize(tab) provoque l’erreur critique décrite dans Array out of range.
  • Copie de données incomplète : CopyClose() peut renvoyer moins d’éléments que demandé, ou -1. Utilisez la valeur renvoyée, pas la quantité demandée, comme borne de boucle.
  • ArrayResize non vérifié : en cas d’échec, le tableau garde son ancienne taille et l’écriture suivante déborde.
  • Agrandissement élément par élément sans réserve : performances dégradées sur de grands volumes ; utilisez reserve_size.
  • Confusion valeur / index : ArrayMaximum() renvoie une position, pas la valeur maximale.
  • Sens d’indexation implicite : selon la manière dont un tableau est rempli et configuré, l’index 0 peut désigner la barre la plus ancienne ou la plus récente. Fixez-le explicitement.

Les tableaux servent aussi à stocker des structures comme MqlRates, présentées dans Structures (struct) et MqlRates, MqlTick.

FAQ

Comment connaître la taille d’un tableau en MQL5 ?

Utilisez ArraySize(), qui renvoie le nombre total d’éléments. Pour un tableau à plusieurs dimensions, ArrayRange(tableau, n) renvoie le nombre d’éléments de la dimension n.

Peut-on redimensionner un tableau statique ?

Non. ArrayResize() ne réalloue pas un tableau statique ; il faut le déclarer dynamique, sans taille entre les premiers crochets, pour pouvoir changer sa taille.

Combien de dimensions un tableau peut-il avoir ?

Quatre au maximum, selon la documentation. Pour un tableau dynamique, seule la première dimension est variable ; les autres doivent être fixées à la déclaration.

Une fonction peut-elle renvoyer un tableau ?

Non, pas avec return. La fonction reçoit le tableau par référence, le remplit, et renvoie généralement le nombre d’éléments écrits ou un booléen de réussite.

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.