Manual de referencia de MQL5Operaciones con arraysArrayCompare

ArrayCompare

Esta función devuelve el resultado de comparación de dos arrays del mismo tipo. Puede ser utilizada para comparar los arrays de tipos simples o estructuras personalizadas que no tienen objetos complejos, es decir, que no contienen cadenas de caracteres, arrays dinámicos, clases u otras estructuras que incluyen objetos complejos.

int  ArrayCompare(
   const void&  array1[],            // el primer array
   const void&  array2[],            // el segundo array
   int          start1=0,            // offset inicial en el primer array
   int          start2=0,            // offset inicial en el segundo array
   int          count=WHOLE_ARRAY    // número de elementos a comparar
   );

Parámetros

array1[]

[in] Primer array.

array2[]

[in] Segundo array.

start1=0

[in] Índice inicial del elemento en el primer array a partir del cual se empieza la comparación. Por defecto, el índice inicial es igual a 0.

start2=0

[in] Índice inicial del elemento en el segundo array a partir del cual se empieza la comparación. Por defecto, el índice inicial es igual a 0.

count=WHOLE_ARRAY

[in] Número de elementos a comparar. Por defecto, en la comparación participan todos los elementos de ambos arrays (count=WHOLE_ARRAY).

Valor devuelto

-1, si array1[] es menor que array2[]
0, si array1[] y array2[] son iguales
1, si array1[] es mayor a array2[]
-2, si surge un error debido a la incompatibilidad de tipos de los arrays comparados, o si los valores start1, start2 o count salen de los límites del array.

Nota

La función no va a devolver 0 (los arrays no van a considerarse iguales), si los arrays que se comparan se diferencian en su tamaño y si se indica el valor count=WHOLE_ARRAY para el caso cuando uno de los arrays es el subconjunto exacto del otro. En este caso será devuelto el resultado de comparación de estos arrays: -1, si el tamaño del array1[] es menor que el tamaño del array2[] o 1 en caso contrario.

Ejemplo:

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

//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- establecemos el tamaño de los arrays
   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;
     }

//--- en un ciclo, rellenamos los arrays con los valores de los índices i y j
   int total=ArraySize(ExtArrayFirst);
   for(int i=0, j=total-1; i<total; i++,j--)
     {
      //--- el array ExtArrayFirst lo rellenamos de izquierda a derecha
      //--- el array ExtArraySecond lo rellenamos de derecha a izquierda
      ExtArrayFirst[i]=i;
      ExtArraySecond[i]=j;
     }
//--- comparamos los arrays e imprimimos el resultado en el diario de registro
   ArrayComparePrint(ExtArrayFirst,ExtArraySecond);
   /*
  Resultado:
   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)
   */

//--- ahora invertimos los arrays
//--- en un ciclo, rellenamos los arrays con los valores de los índices i y j
   for(int i=0, j=total-1; i<total; i++,j--)
     {
      //--- el array ExtArrayFirst lo rellenamos de derecha a izquierda
      //--- el array ExtArraySecond lo rellenamos de izquierda a derecha
      ExtArrayFirst[i]=j;
      ExtArraySecond[i]=i;
     }
//--- comparamos los arrays e imprimimos el resultado en el diario de registro
   ArrayComparePrint(ExtArrayFirst,ExtArraySecond);
   /*
  Resultado:
   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)
   */

//--- ahora rellanamos los arrays en una dirección
//--- en un ciclo, rellenamos los arrays con los valores del índice i
   for(int i=0; i<total; i++)
     {
      //--- ambos arrays los rellenamos de izquierda a derecha
      ExtArrayFirst[i]=i;
      ExtArraySecond[i]=i;
     }
//--- comparamos los arrays e imprimimos el resultado en el diario de registro
   ArrayComparePrint(ExtArrayFirst,ExtArraySecond);
   /*
  Resultado:
   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)
   */
  }
//+------------------------------------------------------------------+
//| Comparar y mostrar resultado                                     |
//+------------------------------------------------------------------+
void ArrayComparePrint(const double &array1[], const double &array2[])
  {
   //--- imprimimos el encabezado y el contenido de los arrays
   Print("ExtArrayFirst:");
   ArrayPrint(array1);
   Print("ExtArraySecond:");
   ArrayPrint(array2);
   //--- comparamos los arrays e imprimimos el resultado de la comparación
   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