ArrayResize

Esta función establece nuevo tamaño en la primera dimensión del array.

int  ArrayResize(
   void&  array[],              // array pasado por referencia
   int    new_size,             // nuevo tamaño del array
   int    reserve_size=0        // valor de reserva del tamaño (sobrante)
   );

Parámetros

array[]

[out]  Array para el cambio de tamaño.

new_size

[in]  Nuevo tamaño para la primera dimensión.

reserve_size=0

[in]  Tamaño para la reserva adicional.

Valor devuelto

Si se ejecuta con éxito, la función devuelve la cantidad de todos los elementos contenidos en el array después del cambio de tamaño; de lo contrario devuelve -1 y el array no cambia sus dimensiones.

Si ArrayResize() se aplica a una matriz estática, a una serie temporal o un búfer de indicador, el tamaño de la matriz permanerecerá igual: estas matrices no pueden ser redistribuidas. En este caso, si new_size<=ArraySize(array), la función simplemente retornará new_size; en caso contrario, retornará -1.

Nota

Esta función puede aplicarse sólo a los arrays dinámicos. Además, hay que tener en cuenta que no se puede cambiar el tamaño de los arrays dinámicos que han sido asignados como búfers de indicadores por la función SetIndexBuffer(). Todas las operaciones relacionadas con el cambio del tamaño de los búfers de indicadores se realizan por el subsistema ejecutivo del terminal.

El número total de los elementos del array no puede superar 2147483647.

En caso de la distribución frecuente de la memoria se recomienda utilizar el tercer parámetro que establece una reserva para disminuir la cantidad de distribución física de la memoria. Las siguientes llamadas a la función ArrayResize no llevan a la redistribución física de la memoria, simplemente se cambia el tamaño de la primera dimensión del array dentro de los límites de la memoria reservada. Hay que recordar que el tercer parámetro va a utilizarse sólo cuando va a tener lugar la distribución física de la memoria, por ejemplo:

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

En este caso se producirá 2 redistribuciones de la memoria: una vez antes de la entrada en el ciclo de 3000 elementos, en este caso la dimensionalidad del array se establecerá en 1000, y la segunda - cuando i es igual a 2000. Si omitimos el tercer parámetro, habrá 2000 redistribuciones físicas de la memoria, y esto ralentizará la ejecución del programa.

Ejemplo:

//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- contadores
   ulong start=GetTickCount();
   ulong now;
   int   count=0;
//--- array para demostración de la versión rápida
   double arr[];
   ArrayResize(arr,100000,100000);
//--- comprobamos con qué rapidez funciona la versión con la reserva de memoria
   Print("--- Test Fast: ArrayResize(arr,100000,100000)");
   for(int i=1;i<=300000;i++)
     {
      //--- ¡fijamos el nuevo tamaño del array indicando la reserva de 100000 elementos!
      ArrayResize(arr,i,100000);
      //--- al alcanzar un número redondo, mostramos el tamaño del array y el tiempo gastado
      if(ArraySize(arr)%100000==0)
        {
         now=GetTickCount();
         count++;
         PrintFormat("%d. ArraySize(arr)=%d Time=%d ms",count,ArraySize(arr),(now-start));
         start=now; 
        }
     }
//--- ahora mostramos qué lento trabaja la versión sin la reserva de la memoria
   double slow[];
   ArrayResize(slow,100000,100000);
//--- 
   count=0;
   start=GetTickCount();
   Print("---- Test Slow: ArrayResize(slow,100000)");
//---
   for(int i=1;i<=300000;i++)
     {
      //--- fijamos el nuevo tamaño del array, pero ya sin la reserva adicional
      ArrayResize(slow,i);
      //--- al alcanzar un número redondo, mostramos el tamaño del array y el tiempo gastado
      if(ArraySize(slow)%100000==0)
        {
         now=GetTickCount();
         count++;
         PrintFormat("%d. ArraySize(slow)=%d Time=%d ms",count,ArraySize(slow),(now-start));
         start=now;
        }
     }
  }
//--- Un resultado aproximado de la ejecución del script
/*
   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
*/

Véase también

ArrayInitialize