Referência MQL5Funções para ArrayArrayCompare

ArrayCompare

A função retorna o resultado da comparação de dois arrays de mesmo tipo. Pode ser usado para comparar arrays de tipos simples ou estruturas customizadas sem objetos complexos, isto é, estruturas customizadas que não contém strings, arrays dinâmicos, classes e outras estruturas com objetos complexos.

int  ArrayCompare(
   const void&  array1[],            // primeiro array
   const void&  array2[],            // segundo array
   int          start1=0,            // deslocamento inicial no primeiro array
   int          start2=0,            // deslocamento inicial no segundo array
   int          count=WHOLE_ARRAY    // número de elementos para comparação
   );

Parâmetros

array1[]

[in] Primeiro array.

array2[]

[in] Segundo array.

start1=0

[in] O índice inicial do elemento no primeiro array, a partir do qual a comparação começa. O índice de começo default - 0.

start2=0

[in] O índice inicial do elemento no segundo array, a partir do qual a comparação começa. O índice de começo default - 0.

count=WHOLE_ARRAY

[in] Número de elementos a ser comparados. Todos os elementos de ambos os arrays participam da comparação por default (count=WHOLE_ARRAY).

Valor de retorno

-1, se array1[] menos que array2[]
0, se array1[] igual a array2[]
1, se array1[] mais que array2[]
-2, se um erro ocorrer devido a incompatibilidade dos tipos dos arrays comparados ou se os valores start1, start2 ou count levarem a cair para fora do array.

Observação

A função não retornará 0 (os arrays não serão considerados iguais) se os arrays diferirem em tamanho e count=WHOLE_ARRAY para o caso em que um array é um subconjunto fiel do outro. Neste caso, o resultado da comparação de tamanhos destes arrays irão retornar: -1, se o tamanho de array1[] for menor que o tamanho de array2[] , caso contrário 1.

Exemplo:

//--- variáveis globais
double   ExtArrayFirst[];
double   ExtArraySecond[];

//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- definimos as dimensões dos 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;
     }

//--- no ciclo, preenchemos os arrays com os valores dos índices i e j
   int total=ArraySize(ExtArrayFirst);
   for(int i=0, j=total-1; i<total; i++,j--)
     {
      //--- preenchemos o array ExtArrayFirst da esquerda para a direita
      //--- preenchemos o array ExtArraySecond da direita para a esquerda
      ExtArrayFirst[i]=i;
      ExtArraySecond[i]=j;
     }
//--- comparamos os arrays e imprimimos o resultado no log
   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)
  */

//--- agora invertemos os arrays
//--- no ciclo, preenchemos os arrays com os valores dos índices i e j
   for(int i=0, j=total-1; i<total; i++,j--)
     {
      //--- preenchemos o array ExtArrayFirst da direita para a esquerda
      //--- preenchemos o array ExtArraySecond da esquerda para a direita
      ExtArrayFirst[i]=j;
      ExtArraySecond[i]=i;
     }
//--- comparamos os arrays e imprimimos o resultado no log
   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)
   */

//--- agora preencheremos os arrays na mesma direção
//--- no ciclo, preenchemos os arrays com os valores do índice i
   for(int i=0; i<total; i++)
     {
      //--- preenchemos ambos os arrays da esquerda para a direita
      ExtArrayFirst[i]=i;
      ExtArraySecond[i]=i;
     }
//--- comparamos os arrays e imprimimos o resultado no log
   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)
   */
  }
//+------------------------------------------------------------------+
//| Comparação e impressão do resultado                              |
//+------------------------------------------------------------------+
void ArrayComparePrint(const double &array1[], const double &array2[])
  {
   //--- imprimimos o cabeçalho e o conteúdo dos arrays
   Print("ExtArrayFirst:");
   ArrayPrint(array1);
   Print("ExtArraySecond:");
   ArrayPrint(array2);
   //--- comparamos os arrays e imprimimos o resultado da comparação
   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