Nachschlagewerk MQL5Operationen mit ArraysArrayResize

ArrayResize

Verändert die Größe der ersten Dimension des Arrays

int  ArrayResize(
   void&  array[],              // Array, das durch Referenz übertragen wurde
   int    new_size,             // die neue Größe des Arrays
   int    reserve_size=0        // Reserve des Arrays (redundant)
   );

Parameter

array[]

[out] das Array, dessen Größe verändert werden soll

new_size

[in] Die neue Größe der ersten Dimension

reserve_size=0

[in] Die Größe für Zusatzreserve

Rückgabewert

Bei erfolgreicher Durchführung gibt die Funktion die Anzahl aller Elemente zurück, die das Array nach der Größenveränderung enthält; anderenfalls gibt -1 zurück und das Array verändert seine Größen nicht.

Wenn ArrayResize() auf ein static Array, eine Zeitreihe oder ein Indikatorpuffer angewendet wird, bleibt die Arraygröße gleich – diese Arrays werden nicht verändert. In diesem Fall, wenn new_size<=ArraySize(array), wird die Funktion new_size zurückgeben, andernfalls den Wert -1.

Hinweis

Die Funktion kann nur auf dynamischen Arrays angewendet werden. Es sollte beachtet werden, dass die Größe dynamischer Arrays, die als Indikatorpuffer mit der Funktion SetIndexBuffer() definiert wurden, nicht verändert werden können. Für Indikatorpuffer werden alle Änderungen der Größe von Laufzeit-Subsystem des Terminals durchgeführt.

Die Gesamtzahl der Elemente im Array darf nicht größer als 2147483647 sein.

Bei häufigen Speicherveränderungen wird empfohlen, den dritten Parameter zu verwenden, der eine Reserve festlegt, um die Anzahl der physikalischen Speicherzuweisungen zu reduzieren. Alle nachfolgenden Aufrufe der Funktion ArrayResize führen dann nicht mehr zu einer neuen physikalischer Speicherzuweisung, in diesen Fällen ändert sich nur die Größe der ersten Dimension des Arrays im reservierten Speicherbereich. Es sei daran erinnert, dass der dritte Parameter nur dann verwendet wird, wenn die physikalische Speicherzuweisung stattfindet, zum Beispiel:

ArrayResize(arr,1000,1000);
for(int i=1;i<3000;i++)
ArrayResize(arr,i,1000);

In diesem Fall gibt es nur zwei Speicherzuweisungen, einmal vor der Schleife mit 3000 Iterationen (dabei wird die Dimension des Arrays auf 1000 festgelegt) und das zweite Mal wenn i gleich 2000 ist. Wenn der dritte Parameter weggelassen worden wäre, würden es 2000 einzelne physikalische Speicherzuweisungen geben, welches die Ausführung des Programms verzögern würde.

Beispiel:

//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- Zähler
   ulong start=GetTickCount();
   ulong now;
   int   count=0;
//--- Array demonstriert die schnelle Version
   double arr[];
   ArrayResize(arr,100000,100000);
//--- Prüfen wir, wie schnell die Version mit Reservierung von Speicher arbeitet
   Print("--- Test Fast: ArrayResize(arr,100000,100000)");
   for(int i=1;i<=300000;i++)
     {
      //--- Geben wir eine neue Arraygröße ein mit einer Reserve von 100000 Elementen!
      ArrayResize(arr,i,100000);
      //--- Wenn eine runde Zahl erreicht wird, wird die Größe des Arrays und die benötigte Zeit angezeigt
      if(ArraySize(arr)%100000==0)
        {
         now=GetTickCount();
         count++;
         PrintFormat("%d. ArraySize(arr)=%d Time=%d ms",count,ArraySize(arr),(now-start));
         start=now;
        }
     }
//--- Jetzt zeigen wir wie langsam die Version ohne reserviertem Speicher ist
   double slow[];
   ArrayResize(slow,100000,100000);
//---
   count=0;
   start=GetTickCount();
   Print("---- Test Slow: ArrayResize(slow,100000)");
//---
   for(int i=1;i<=300000;i++)
     {
      //--- Geben wir eine neue Arraygröße ohne die zusätzliche Reserve
      ArrayResize(slow,i);
      //--- Wenn eine runde Zahl erreicht wird, wird die Größe des Arrays und die benötigte Zeit angezeigt
      if(ArraySize(slow)%100000==0)
        {
         now=GetTickCount();
         count++;
         PrintFormat("%d. ArraySize(slow)=%d Time=%d ms",count,ArraySize(slow),(now-start));
         start=now;
        }
     }
  }
//--- Ergebnis des Beispiel-Skripts
/*
   Test_ArrayResize (EURUSD,H1)   --- Test Fast: ArrayResize(arr,100000,100000)
   Test_ArrayResize (EURUSD,H1)   1. ArraySize(arr)=100000 Time=0 ms
   Test_ArrayResize (EURUSD,H1)   2. ArraySize(arr)=200000 Time=0 ms
   Test_ArrayResize (EURUSD,H1)   3. ArraySize(arr)=300000 Time=0 ms
   Test_ArrayResize (EURUSD,H1)   ---- Test Slow: ArrayResize(slow,100000)
   Test_ArrayResize (EURUSD,H1)   1. ArraySize(slow)=100000 Time=0 ms
   Test_ArrayResize (EURUSD,H1)   2. ArraySize(slow)=200000 Time=0 ms
   Test_ArrayResize (EURUSD,H1)   3. ArraySize(slow)=300000 Time=228511 ms
*/

Siehe auch

ArrayInitialize

ArrayRange

ArrayInsert