Nachschlagewerk MQL5Operationen mit ArraysArrayCompare

ArrayCompare

Gibt das Ergebnis eines Vergleichs von zwei Arrays des gleichen Typs zurück. Es kann verwendet werden, um Arrays von einfachen Typen oder angepassten Strukturen ohne komplexe Objekte zu vergleichen - d.h. die keine Zeichen, dynamische Arrays von Klassen oder anderen Strukturen mit komplexe Objekten enthalten.

int  ArrayCompare(
   const void&  array1[],            // das erste Array
   const void&  array2[],            // das zweite Array
   int          start1=0,            // Anfangsversatz im ersten Array
   int          start2=0,            // Anfangsversatz im zweiten Array
   int          count=WHOLE_ARRAY    // Anzahl der Elemente für den Vergleich
   );

Parameter

array1[]

[in] Das erste Array.

array2[]

[in] Das zweite Array.

start1=0

[In] Der Ausgangsindex des Elementes im ersten Array, mit dem der Vergleich beginnen wird. Als Voreinstellung der Startindex - 0.

start2=0

[In] Der Ausgangsindex des Elementes im zweiten Array, mit dem der Vergleich beginnen wird. Als Voreinstellung der Startindex - 0.

count=WHOLE_ARRAY

[in] Die Anzahl der Elemente, die man vergleichen muss. Als Voreinstellung beteiligt alle Elemente beider Arrays in dem Vergleich (count=WHOLE_ARRAY).

Der Rückgabewert

-1, wenn array1[] weniger als array2[]
0, wenn array1[] und array2[] sind gleich
1, wenn array1[] mehr als array2[]
2, Beim Auftreten des Fehlers wegen der Inkompatibilität der Typen der verglichenen Arrays, oder wenn es start1, start2 oder count Werte gibt, die zum Ausgang aus dem Grenzen von Array bringen.

Hinweis

Bei unterschiedlichen Größen der zu vergleichenden Arrays und dem angegebenen Wert count=WHOLE_ARRAY für den Fall, dass ein Array eine exakte Teilmenge eines anderen ist, wird die Funktion nicht 0 zurückgeben (die Arrays werden al ungleich angesehen). In diesem Fall wird als Ergebnis des Vergleichs eine Art Größenvergleich der beiden Arrays zurückgegeben: -1, wenn die Größe von array1[] kleiner ist als die Größe von array2[], ansonsten 1.

Beispiel:

//--- globale Variable
double   ExtArrayFirst[];
double   ExtArraySecond[];

//+------------------------------------------------------------------+
//| Skript Programm Start Funktion                                   |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- Array-Größe festlegen
   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;
     }

//--- Füllen des Arrays mit den Indexwerten von i und j in einer Schleife
   int total=ArraySize(ExtArrayFirst);
   for(int i=0, j=total-1; i<total; i++,j--)
     {
      //--- Füllen des Arrays ExtArrayFirst von links nach rechts
      //--- Füllen des Arrays ExtArraySecond von rechts nach links
      ExtArrayFirst[i]=i;
      ExtArraySecond[i]=j;
     }
//--- Arrays vergleichen und der Ausgabe des Ergebnisses im Log
   ArrayComparePrint(ExtArrayFirst,ExtArraySecond);
   /*
  Ergebnis:
   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)
   */

//--- jetzt spiegeln wir die Arrays
//--- Füllen des Arrays mit den Indexwerten von i und j in einer Schleife
   for(int i=0, j=total-1; i<total; i++,j--)
     {
      //--- Füllen des Arrays ExtArrayFirst von rechts nach links
      //--- Füllen des Arrays ExtArraySecond von links nach rechts
      ExtArrayFirst[i]=j;
      ExtArraySecond[i]=i;
     }
//--- Arrays vergleichen und der Ausgabe des Ergebnisses im Log
   ArrayComparePrint(ExtArrayFirst,ExtArraySecond);
   /*
  Ergebnis:
   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)
   */

//--- Füllen wir nun die Felder in eine Richtung
//--- Füllen der Arrays mit den Indexwerten i in einer Schleife
   for(int i=0; i<total; i++)
     {
      //--- Füllen beider Arrays von links nach rechts
      ExtArrayFirst[i]=i;
      ExtArraySecond[i]=i;
     }
//--- Arrays vergleichen und der Ausgabe des Ergebnisses im Log
   ArrayComparePrint(ExtArrayFirst,ExtArraySecond);
   /*
  Ergebnis:
   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)
   */
  }
//+------------------------------------------------------------------+
//| Vergleichen und Anzeigen des Ergebnisses                         |
//+------------------------------------------------------------------+
void ArrayComparePrint(const double &array1[], const double &array2[])
  {
   //--- Ausdruck der Kopfzeile und des Arrayinhalts
   Print("ExtArrayFirst:");
   ArrayPrint(array1);
   Print("ExtArraySecond:");
   ArrayPrint(array2);
   //--- die Arrays vergleichen und das Vergleichsergebnis ausgeben
   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