MetaTrader 4 Build 900: Plantillas de clases en MQL4 y optimización del trabajo con la memoria

Últimas actualizaciones de MetaTrader 4

22 octubre 2015

Terminal

  1. Corregido el error del cambio de contraseña de una cuenta inactiva (no conectada).



  2. Terminal: Optimizado el uso y liberación de memoria al trabajar con grandes volúmenes de datos históricos.
  3. Terminal: Corregido y optimizado el trabajo con grandes cantidades de categorías de noticias.

Signals

  1. Corregida la baja del servicio de señales en el menú de contexto de la ventana "Navegador".



MQL4

  1. Añadidas las plantillas de clases, que permiten crear clases parametrizadas como en C++. Esto permitirá lograr una mayor abstracción y usar el mismo código para trabajar de una manera uniforme con objetos de diferentes clases. Ejemplo de uso:
    //+------------------------------------------------------------------+
    //|                                                    TemplTest.mq5 |
    //|                        Copyright 2015, MetaQuotes Software Corp. |
    //|                                             https://www.mql5.com |
    //+------------------------------------------------------------------+
    #property copyright "Copyright 2015, MetaQuotes Software Corp."
    #property link      "https://www.mql5.com"
    #property version   "1.00"
    //+------------------------------------------------------------------+
    //| Anunciamos la plantilla de clase                                        |
    //+------------------------------------------------------------------+
    template<typename T>
    class TArray
      {
    protected:
       T                 m_data[];
    
    public:
    
       bool              Append(T item)
         {
          int new_size=ArraySize(m_data)+1;
          int reserve =(new_size/2+15)&~15;
          //---
          if(ArrayResize(m_data,new_size,reserve)!=new_size)
             return(false);
          //---
          m_data[new_size-1]=item;
          return(true);
         }
       T                 operator[](int index)
         {
          static T invalid_index;
          //---
          if(index<0 || index>=ArraySize(m_data))
             return(invalid_index);
          //---
          return(m_data[index]);
         }   
      };
    //+------------------------------------------------------------------+
    //| La plantilla de clase de la matriz de índices, en el destructor elimina     |
    //| aquellos objetos a los que se referían los índices guardados en la matriz.                   |
    //|                                                                  |
    //| Preste atención a la herencia de la plantilla de la clase TArray    |
    //+------------------------------------------------------------------+
    template<typename T>
    class TArrayPtr : public TArray<T *>
      {
    public:
       void             ~TArrayPtr()
         {
          for(int n=0,count=ArraySize(m_data);n<count;n++)
             if(CheckPointer(m_data[n])==POINTER_DYNAMIC)
                delete m_data[n];
         }
      };
    //+------------------------------------------------------------------+
    //| Anunciamos la clase, los índices a sus objetos los guardaremos en la matriz  |
    //+------------------------------------------------------------------+
    class CFoo
      {
       int               m_x;
    public:
                         CFoo(int x):m_x(x) { }
       int               X(void) const { return(m_x); }
      };
    //+------------------------------------------------------------------+
    //|                                                                  |
    //+------------------------------------------------------------------+
    TArray<int>     ExtIntArray;   // instanciamos la plantilla TArray (especializamos la plantilla TArray con el tipo int)
    TArray<double>  ExtDblArray;   // instanciamos la plantilla TArray (especializamos la plantilla TArray con el tipo double)
    TArrayPtr<CFoo> ExtPtrArray;   // instanciamos la plantilla TArrayPtr (especializamos la plantilla TArrayPtr con el tipo CFoo)
    //+------------------------------------------------------------------+
    //| Script program start function                                    |
    //+------------------------------------------------------------------+
    void OnStart()
      {
    //--- llenamos las matrices con datos
       for(int i=0;i<10;i++)
         {
          int integer=i+10;
          ExtIntArray.Append(integer);
          
          double dbl=i+20.0;
          ExtDblArray.Append(dbl);
          
          CFoo *ptr=new CFoo(i+30);
          ExtPtrArray.Append(ptr);
         }
    //--- generamos el contenido de las matrices
       string str="Int:";
       for(i=0;i<10;i++)
          str+=" "+(string)ExtIntArray[i];      
       Print(str);   
       str="Dbl:";
       for(i=0;i<10;i++)
          str+=" "+DoubleToString(ExtDblArray[i],1);
       Print(str);   
       str="Ptr:";
       for(i=0;i<10;i++)
          str+=" "+(string)ExtPtrArray[i].X();      
       Print(str);
    //--- no es necesario eliminar los objetos CFoo creados a través de new, se eliminan en el destructor del objeto TArrayPtr<CFoo>  
      }
    Resultado de la ejecución:
    TemplTest EURUSD,M1: Ptr: 30 31 32 33 34 35 36 37 38 39
    TemplTest EURUSD,M1: Dbl: 20.0 21.0 22.0 23.0 24.0 25.0 26.0 27.0 28.0 29.0
    TemplTest EURUSD,M1: Int: 10 11 12 13 14 15 16 17 18 19
  2. Corregida la redistribución de la memoria en la función ArrayCopy, que en ciertos casos provocaba la caída de los programas MQL4.

Tester

  1. Corregido el error que provocaba la puesta a cero de las variables anunciadas a nivel global después de finalizar la simulación del indicador.
  2. Corregida la simulación en ausencia de conexión con el servidor comercial.

MetaEditor

  1. MetaEditor: En MetaAssist se ha corregido la determinación del nombre de la función, en caso de que se muestre el tipo.
  2. MetaEditor: Corregida la apertura de grandes archivos.
  3. MetaEditor: Añadido el botón de acceso rápido F para iniciar la búsqueda desde la pestaña Biblioteca, así como multitud de pistas en la línea de estado, para los comandos de trabajo con el código: aumento/reducción de la sangría, desplazamiento, cambio de registro, etcétera.


Correciones de crash logs.