MQL5 RiferimentoFunzioni di ArrayArrayCompare

ArrayCompare

La funzione restituisce il risultato del confronto di due array dello stesso tipo. Esso può essere utilizzato per confrontare gli array di tipi semplici o strutture personalizzate senza oggetti complessi, che sono le strutture personalizzate che non contengono stringhe, array dinamici, classi e le altre strutture con oggetti complessi.

int  ArrayCompare(
   const void&  array1[],            // primo array
   const void&  array2[],            // secondo array
   int          start1=0,            // offset iniziale nel primo array
   int          start2=0,            // offset iniziale nel secondo array
   int          count=WHOLE_ARRAY    // numero di elementi per il confronto
   );

Parametri

array1[]

[in] Primo array.

array2[]

[in] Secondo array.

start1=0

[in] L'indice iniziale dell'elemento nel primo array, da cui inizia il confronto. L'inice di inizio di default - 0.

start2=0

[in] L'indice iniziale dell'elemento nel secondo array, da cui inizia il confronto. L'inice di inizio di default - 0.

count=WHOLE_ARRAY

[in] Numero di elementi da confrontare. Tutti gli elementi di entrambi gli array partecipano al confronto per default (count =WHOLE_ARRAY).

Valore restituito

-1, se array1 [] è meno di array2 []
0, se array1 [] è pari ad array2 []
1, se array1 [] è più di array2 []
-2, Se si verifica un errore a causa di incompatibilità dei tipi di array comparati, o se start1, start2 o valori di conteggio portano all'uscita di fuori dall'array.

Nota

La funzione non restituirà 0 (gli array non saranno considerati uguali) se gli array si differenziano per dimensioni e count=WHOLE_ARRAY per il caso in cui un array è un fedele sottoinsieme di un altro. In questo caso, il risultato del confronto delle grandezze di quelli array sarà restituito: -1, se la grandezza dell'array1 [] è inferiore alla grandezza dell' array2 [] , Altrimenti 1.

Esempio:

//---variabili globali
double   ExtArrayFirst[];
double   ExtArraySecond[];

//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//---imposta la dimensione degli array
   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;
     }

//-- riempire gli array con i valori degli indici i e j in un ciclo
   int total=ArraySize(ExtArrayFirst);
   for(int i=0, j=total-1; i<total; i++,j--)
     {
//-- riempire l'array ExtArrayFirst da sinistra a destra
//-- riempire l'array ExtArraySecond da destra a sinistra
      ExtArrayFirst[i]=i;
      ExtArraySecond[i]=j;
     }
//--- confrontare gli array e stampare il risultato nel log
   ArrayComparePrint(ExtArrayFirst,ExtArraySecond);
   /*
  Risultato:
   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)
   */

//--- ora capovolgiamo gli array
//-- riempire gli array con i valori degli indici i e j in un ciclo
   for(int i=0, j=total-1; i<total; i++,j--)
     {
//-- riempire l'array ExtArrayFirst da destra a sinistra
      //-- riempire l'array ExtArraySecond da sinistra a destra
      ExtArrayFirst[i]=j;
      ExtArraySecond[i]=i;
     }
//--- confrontare gli array e stampare il risultato nel log
   ArrayComparePrint(ExtArrayFirst,ExtArraySecond);
   /*
  Risultato:
   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)
   */

//--- ora riempiamo gli array in una direzione
//-- riempiamo gli array con i valori dell'indice i in un loop
   for(int i=0; i<total; i++)
     {
//-- riempire entrambi gli array da sinistra a destra
      ExtArrayFirst[i]=i;
      ExtArraySecond[i]=i;
     }
//--- confrontare gli array e stampare il risultato nel log
   ArrayComparePrint(ExtArrayFirst,ExtArraySecond);
   /*
  Risultato:
   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)
   */
  }
//+------------------------------------------------------------------+
//| Confronta e visualizza il risultato                              |
//+------------------------------------------------------------------+
void ArrayComparePrint(const double &array1[], const double &array2[])
  {
//-- stampa l'intestazione e il contenuto degli array
   Print("ExtArrayFirst:");
   ArrayPrint(array1);
   Print("ExtArraySecond:");
   ArrayPrint(array2);
//-- confronta gli array e stampa il risultato del confronto
   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