Référence MQL5Fonctions sur les TableauxArrayCompare

ArrayCompare

La fonction retourne le résultat de la comparaison de deux tableaux du même type. Elle peut être utilisée pour comparer des tableaux d'éléments de types simples ou des structures personnalisées sans objets complexes, c'est à dire des structures ne contenant pas d'objets de type string, de tableaux dynamiques, de classes ou d'autres structures contenant des objets complexes.

int  ArrayCompare(
   const void&  array1[],            // premier tableau
   const void&  array2[],            // deuxième tableau
   int          start1=0,            // décalage initial du premier tableau
   int          start2=0,            // décalage initial du deuxième tableau
   int          count=WHOLE_ARRAY    // nombre d'éléments à comparer
   );

Paramètres

array1[]

[in] Premier tableau.

array2[]

[in] Deuxième tableau.

start1=0

[in] L'indice initial de l'élément dans le premier tableau, à partir duquel la comparaison commence. L'indice de début par défaut est 0.

start2=0

[in] L'indice initial de l'élément dans le deuxième tableau, à partir duquel la comparaison commence. L'indice de début par défaut est 0.

count=WHOLE_ARRAY

[in] Nombre d'éléments à comparer. Tous les éléments des deux tableaux participent par défaut à la comparaison (count=WHOLE_ARRAY).

Valeur de Retour

-1, si array1[] est inférieur à array2[]
0, si array1[] est égal à array2[]
1, si array1[] est supérieur à array2[]
-2, si une erreur est survenue en raison d'une incompatibilité des types des tableaux comparés ou si start1, start2 ou le nombre de valeurs comptées dépassent les limites du tableau.

Note

La fonction ne retournera pas 0 (les tableaux ne seront pas considérés comme égaux) si les tableaux diffèrent en taille et que count=WHOLE_ARRAY pour le cas où un tableau est un sous-ensemble de l'autre. Dans ce cas, le résultat de la comparaison des tailles de ces tableaux retournera : -1, si la taille de array1[] est inférieure à celle de array2[] , sinon 1.

Exemple :

//--- variables globales
double   ExtArrayFirst[];
double   ExtArraySecond[];

//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- défini la taille des tableaux
   if(ArrayResize(ExtArrayFirst,10)!=10)
     {
      Print("ArrayResize() failed for ExtArrayFirst. Error code: ",GetLastError());
      return;
     }
   if(ArrayResize(ExtArraySecond,10)!=10)
     {
      Print("ArrayResize() failed for ExtArraySecond. Error code: ",GetLastError());
      return;
     }

//--- remplit les tableaux avec les valeurs des indices i et j dans une boucle
   int total=ArraySize(ExtArrayFirst);
   for(int i=0, j=total-1; i<total; i++,j--)
     {
      //--- remplit le tableau ExtArrayFirst de gauche à droite
      //--- remplit le tableau ExtArraySecond de droite à gauche
      ExtArrayFirst[i]=i;
      ExtArraySecond[i]=j;
     }
//--- compare les tableaux et écrit le résultat dans le journal
   ArrayComparePrint(ExtArrayFirst,ExtArraySecond);
   /*
  Résultat :
   ExtArrayFirst:
   0.00000 1.00000 2.00000 3.00000 4.00000 5.00000 6.00000 7.00000 8.00000 9.00000
   ExtArraySecond:
   9.00000 8.00000 7.00000 6.00000 5.00000 4.00000 3.00000 2.00000 1.00000 0.00000
   Result ArrayCompare(): ExtArrayFirst is smaller than ExtArraySecond (result = -1)
   */

//--- maintenant retournons les tableaux
//--- remplit les tableaux avec les valeurs des indices i et j dans une boucle
   for(int i=0, j=total-1; i<total; i++,j--)
     {
      //--- remplit le tableau ExtArrayFirst de droite à gauche
      //--- remplit le tableau ExtArraySecond de gauche à droite
      ExtArrayFirst[i]=j;
      ExtArraySecond[i]=i;
     }
//--- compare les tableaux et écrit le résultat dans le journal
   ArrayComparePrint(ExtArrayFirst,ExtArraySecond);
   /*
  Résultat :
   ExtArrayFirst:
   9.00000 8.00000 7.00000 6.00000 5.00000 4.00000 3.00000 2.00000 1.00000 0.00000
   ExtArraySecond:
   0.00000 1.00000 2.00000 3.00000 4.00000 5.00000 6.00000 7.00000 8.00000 9.00000
   Result ArrayCompare(): ExtArrayFirst is larger than ExtArraySecond (result = 1)
   */

//--- maintenant remplissons les tableaux dans une direction
//--- remplit les tableaux avec les valeurs de i index dans une boucle
   for(int i=0; i<total; i++)
     {
      //--- remplit les deux tableaux de gauche à droite
      ExtArrayFirst[i]=i;
      ExtArraySecond[i]=i;
     }
//--- compare les tableaux et écrit le résultat dans le journal
   ArrayComparePrint(ExtArrayFirst,ExtArraySecond);
   /*
  Résultat :
   ExtArrayFirst:
   0.00000 1.00000 2.00000 3.00000 4.00000 5.00000 6.00000 7.00000 8.00000 9.00000
   ExtArraySecond:
   0.00000 1.00000 2.00000 3.00000 4.00000 5.00000 6.00000 7.00000 8.00000 9.00000
   Result ArrayCompare(): ExtArrayFirst and ExtArraySecond are equal (result = 0)
   */
  }
//+------------------------------------------------------------------+
//| Compare et affiche le résultat                                   |
//+------------------------------------------------------------------+
void ArrayComparePrint(const double &array1[], const double &array2[])
  {
   //--- affiche l'en-tête et le contenu des tableaux
   Print("ExtArrayFirst:");
   ArrayPrint(array1);
   Print("ExtArraySecond:");
   ArrayPrint(array2);
   //--- compare les tableaux et affiche le résultat de la comparaison
   int    res=ArrayCompare(array1,array2);
   string res_str=(res>0 ? "ExtArrayFirst is larger than ExtArraySecond" : res<0 ? "ExtArrayFirst is smaller than ExtArraySecond" : "ExtArrayFirst and ExtArraySecond are equal");
   PrintFormat("Result ArrayCompare(): %s (result = %d)\n",res_str,res);
  }
//+------------------------------------------------------------------+

ArrayCopy

ArrayFree