Descargar MetaTrader 5

MQL para "Dummies": Cómo Diseñar y Construir Clases de Objetos

7 febrero 2014, 13:53
Sergey Pavlov
0
679

Introducción a la Programación Orientada al Objeto (OOP, por sus siglas en inglés)

Pregunta para "dummies": ¿es posible dominar la OOP y usarla al escribir estrategias de trading automatizadas solo con un entendimiento muy básico de programación procedimental? ¿O es algo que no está al alcance de un usuario estándar?

Por supuesto que es posible usar el lenguaje de programación orientada al objeto para escribir un Asesor Experto MQL5 o indicador sin el uso de principios de programación orientada al objeto. El uso de nuevas tecnologías en sus desarrollos no es obligatorio. Elija la forma que considere más sencilla. Además, la aplicación de la OOP no puede garantizar la rentabilidad de los robots de trading que usted cree.

No obstante, la transición a un enfoque nuevo (orientado al objeto) abre la posibilidad de aplicar modelos matemáticos adaptables más complejos de estrategias de trading a sus Asesores Expertos, que reaccionarán a cambios externos y se sincronizarán con el mercado.

Veamos las tecnologías en las que se basa la OOP:

  1. Eventos
  2. Clases de objetos

Los eventos son la base principal de la OOP. Toda la lógica del programa se basa en procesar los eventos que se suceden continuamente. Las reacciones correctas a todos ellos se definen y describen en las clases de objetos. En otras palabras, una clase de objeto funciona interceptando y procesando el flujo de eventos.

La segunda base es la clase de objetos, que a su vez se basa en los "tres pilares":

  1. Encapsulation (Encapsulación) - Protección de clase basada en el principio de "caja negra": el objeto reacciona a eventos, pero la implementación factual sigue siendo desconocida. 
  2. Inheritance (Herencia) - La posibilidad de crear una clase nueva de una ya existente preservando todas las propiedades y métodos de la clase "antecesora".
  3. Polymorphism (Polimorfismo) - La habilidad de cambiar la implementación de un método heredado en una clase "descendiente".

Los conceptos básicos se demuestran mejor en el código del Asesor Experto.

Eventos:

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()                        // OnInit event processing
  {
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)     // OnDeInit event processing
  {
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()                       // OnTick event processing
  {
  }
//+------------------------------------------------------------------+
//| Expert Timer function                                            |
//+------------------------------------------------------------------+
void OnTimer()                      // OnTimer event processing
  {
  }
//+------------------------------------------------------------------+
//| Expert Chart event function                                      |
//+------------------------------------------------------------------+
void OnChartEvent(const int id,     // OnChartEvent event processing
                  const long &lparam,
                  const double &dparam,
                  const string &sparam)
  {
  }

Clase de Objeto:

class CNew:public CObject
  {
private:
   int               X,Y;
   void              EditXY();
protected:
   bool              on_event;      //events processing flag
public:
   // Class constructor
   void              CNew();
   // OnChart event processing method
   virtual void      OnEvent(const int id,
                             const long &lparam,
                             const double &dparam,
                             const string &sparam);
  };

Encapsulación:

private:
   int               X,Y;
   void              EditXY();

Herencia:

class CNew: public CObject

Polimorfismo:

   // OnChart event processing method
   virtual void      OnEvent(const int id,
                             const long &lparam,
                             const double &dparam,
                             const string &sparam);

El modificador virtual de este método significa que el controlador OnEvent se puede invalidar, pero el nombre del método en esta clase se mantiene igual que la de la clase antecesora.

2. Clases de Diseño

Una de las mayores ventajas de la OOP es que es extensible, lo que significa que el sistema existente es capaz de trabajar con nuevos componentes sin hacer ningún cambio en él. En este punto se pueden añadir nuevos componentes.

Considere el proceso de diseño creando un programa de diseño visual de clases MasterWindows para MQL5.

2.1. 1ª Fase: Borrador de Proyecto

El proceso de diseño comienza con un borrador dibujado a lápiz en una hoja de papel. Este es uno de los momentos más emocionantes y difíciles en el proceso de programación. No solo debemos tener en cuenta el diálogo entre el programa y el usuario (la interfaz), sino también la organización del procesamiento de datos. Este proceso puede durar más de un día. Lo mejor es empezar con la interfaz, porque puede resultar (en algunos casos, como en nuestro ejemplo) el elemento definitivo al estructurar un algoritmo.

Para la organización del diálogo del programa creado, usaremos el modelo parecido a la ventana de aplicación de Windows (vea el borrador de la Figura 1). Contiene líneas, y estas a su vez están compuestas de celdas, y las celdas de los objetos gráficos. Así, ya en la fase del diseño conceptual comenzamos a ver la estructura del programa y la clasificación de objetos.

Figura 1. Modelo de las clases de constructor (borrador)

Figura 1. Modelo de las clases de constructor (borrador)

Con un número de filas y celdas (campos) suficientemente grande en el modelo, se construyen solo a partir de dos tipos de objetos gráficos: OBJ_EDIT y OBJ_BUTTON. Por tanto, una vez que determinamos la apariencia visual, la estructura y los objetos básicos creados por el programa, podemos deducir que el borrador del diseño está listo, y es el momento de pasar a la siguiente fase.

2.2 2ª Fase: Diseño de la Clase Base

Hasta ahora hay tres clases, y más adelante se pueden añadir más (si es necesario):

  • celda de clase CCell;
  • fila de clase CRow, que consta de celdas de clase CCell;
  • ventana de clase CWin, que consta de líneas de clase CRow.

Ahora podemos proceder directamente a las clases de programación, pero... Todavía debemos resolver un asunto muy importante: el intercambio de datos entre objetos de clases. Con este propósito, el lenguaje de MQL5 contiene, además de las variables corrientes, un nuevo tipo: structure (estructura). Por supuesto, en esta fase del diseño no podemos ver todas las conexiones, y es difícil calcularlas. Por tanto, rellenaremos poco a poco la descripción de clases y estructuras conforme el proyecto se vaya desarrollando. Además, los principios de la OOP no obstaculizan este proceso, sino más bien al contrario: fomentan la tecnología o programación.

Estructura WinCell:

struct WinCell
  {
   color             TextColor;     // text color
   color             BGColor;       // background color
   color             BGEditColor;   // background color while editing
   ENUM_BASE_CORNER  Corner;         // anchor corner
   int               H;            // cell height
   int               Corn;         // displacement direction (1;-1)
  };

Las estructuras que no contienen cadenas de caracteres y objetos de arrays dinámicos se llaman estructuras simples. Las variables de estas estructuras se pueden copiar libremente unas en otras, incluso si son estructuras diferentes. La estructura establecida es exactamente de este tipo. Más adelante evaluaremos sus efectividad.

Clase base CCell:

//+------------------------------------------------------------------+
//| CCell base class                                                 |
//+------------------------------------------------------------------+
class CCell
  {
private:
protected:
   bool              on_event;      // event processing flag
   ENUM_OBJECT       type;           // cell type
public:
   WinCell           Property;     // cell property
   string            name;          // cell name
   //+---------------------------------------------------------------+
   // Class constructor
   void              CCell();
   virtual     // Draw method
   void              Draw(string m_name,
                          int m_xdelta,
                          int m_ydelta,
                          int m_bsize);
   virtual     // Event processing method
   void              OnEvent(const int id,
                             const long &lparam,
                             const double &dparam,
                             const string &sparam);
  };

Clase base CRow:

//+------------------------------------------------------------------+
//| CRow base class                                                  |
//+------------------------------------------------------------------+
class CRow
  {
protected:
   bool              on_event;      // event processing flag
public:
   string            name;          // row name
   WinCell           Property;     // row property
   //+---------------------------------------------------------------+
   // Class constructor
   void              CRow();
   virtual     // Draw method
   void              Draw(string m_name,
                          int m_xdelta,
                          int m_ydelta,
                          int m_bsize);
   virtual     // Event processing method
   void              OnEvent(const int id,
                             const long &lparam,
                             const double &dparam,
                             const string &sparam);
  };

Clase base CWin:

//+------------------------------------------------------------------+
//| Base CWin class (WINDOW)                                         |
//+------------------------------------------------------------------+
class CWin
  {
private:
   void              SetXY(int m_corner); //Coordinates
protected:
   bool              on_event;   // event processing flag
public:
   string            name;       // window name
   int               w_corner;   // window corner
   int               w_xdelta;   // vertical delta
   int               w_ydelta;   // horizontal detla
   int               w_xpos;     // X coordinate
   int               w_ypos;     // Y coordinate
   int               w_bsize;    // Window width
   int               w_hsize;    // Window height
   int               w_h_corner; // hide mode corner
   WinCell           Property;   // Property
   //---
   CRowType1         STR1;       // CRowType1
   CRowType2         STR2;       // CRowType2
   CRowType3         STR3;       // CRowType3
   CRowType4         STR4;       // CRowType4
   CRowType5         STR5;       // CRowType5
   CRowType6         STR6;       // CRowType6
   //+---------------------------------------------------------------+
   // Class constructor
   void              CWin();
   // Set window properties
   void              SetWin(string m_name,
                            int m_xdelta,
                            int m_ydelta,
                            int m_bsize,
                            int m_corner);
   virtual     // Draw window method
   void              Draw(int &MMint[][3],
                          string &MMstr[][3],
                          int count);
   virtual     // OnEventTick handler
   void              OnEventTick();
   virtual     // OnChart event handler method
   void              OnEvent(const int id,
                             const long &lparam,
                             const double &dparam,
                             const string &sparam);
  };

Explicaciones y recomendaciones:

  • Todas las clases base (en este proyecto) contienen métodos de procesamiento de eventos. Estos se requieren para interceptar y transmitir eventos a través de la cadena. Sin un mecanismo para recibir y enviar eventos, el programa (o módulo) pierde su interactividad.
  • Al desarrollar una clase base, intente construirla con un número mínimo de métodos. A continuación, implemente varias extensiones de esta clase en las clases "descendientes", que potenciarán la funcionalidad de los objetos creados.
  • ¡No use una llamada directa a los datos internos de otra clase!

2.3. 3ª Fase: Proyecto en Funcionamiento

Ahora comenzaremos con la creación del programa paso a paso. Empezando por el marco de apoyo, aumentaremos sus componentes funcionales y los llenaremos con contenidos. Durante este proceso, monitorizaremos la corrección del trabajo, aplicaremos sistemas de depuración con un código optimizado y rastrearemos los errores que aparezcan.

Pero antes, detengámonos un momento y pensemos en la tecnología de la creación del marco de trabajo, que funcionará para casi cualquier programa. El principal requisito para ello: debe ser inmediatamente funcional (compilado sin errores y que funcione al momento de su ejecución). Los diseñadores de lenguaje se han ocupado de ello y aconsejan usar la plantilla Asesor Experto, que se genera con el MQL5 Wizard como marco de trabajo.

Como ejemplo, consideremos nuestra propia versión de esta plantilla:

1) Programa = Asesor Experto

//+------------------------------------------------------------------+
//|                                                MasterWindows.mq5 |
//|                                                 Copyright DC2008 |
//|                                              http://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "DC2008"
#property link      "http://www.mql5.com"
#property version   "1.00"
//--- include files with classes
#include <ClassMasterWindows.mqh>
//--- Main module declaration
CMasterWindows    MasterWin;
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- Launch of the main module
   MasterWin.Run();
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//--- Deinitialization of the main module
   MasterWin.Deinit();
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- call OnTick event handler of main module
   MasterWin.OnEventTick();
  }
//+------------------------------------------------------------------+
//| Expert Event function                                            |
//+------------------------------------------------------------------+
void OnChartEvent(const int id,
                  const long &lparam,
                  const double &dparam,
                  const string &sparam)
  {
//--- call OnChartEvent handler of main module
   MasterWin.OnEvent(id,lparam,dparam,sparam);
  }

Este es el código completo del Asesor Experto. ¡No son necesarios cambios adicionales en el proyecto!

2) El módulo principal = clase

Todos los módulos auxiliares del proyecto comenzarán su desarrollo a partir de aquí. Este enfoque facilita la programación de proyectos complejos multi-modulares y la búsqueda de posibles errores. Pero encontrarlos es muy difícil. A veces, es más fácil y rápido escribir un nuevo proyecto que buscar los escurridizos "bugs".

//+------------------------------------------------------------------+
//|                                           ClassMasterWindows.mqh |
//|                                                 Copyright DC2008 |
//|                                              http://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "DC2008"
#property link      "http://www.mql5.com"
//+------------------------------------------------------------------+
//| Main module: CMasterWindows class                                |
//+------------------------------------------------------------------+
class CMasterWindows
  {
protected:
   bool              on_event;   // event processing flag
public:
   // Class constructor
   void              CMasterWindows();
   // Method of launching the main module (core algorithm)
   void              Run();
   // Deinitialization method
   void              Deinit();
   // OnTick event processing method
   void              OnEventTick();
   // OnChartEvent event processing method
   void              OnEvent(const int id,
                             const long &lparam,
                             const double &dparam,
                             const string &sparam);
  };

A continuación puede ver un borrador de descripción inicial de los principales métodos de la clase.

//+------------------------------------------------------------------+
//| CMasterWindows class constructor                                 |
//+------------------------------------------------------------------+
void CMasterWindows::CMasterWindows()
   {
//--- class members initialization
   on_event=false;   // disable events processing
   }
//+------------------------------------------------------------------+
//| Метод запуска главного модуля (основной алгоритм)                |
//+------------------------------------------------------------------+
void CMasterWindows::Run()
   {
//--- Main functional of the class: runs additional modules
   ObjectsDeleteAll(0,0,-1);
   Comment("MasterWindows for MQL5     © DC2008");
//---
   on_event=true;   // enable events processing
   }
//+------------------------------------------------------------------+
//| Deinitialization method                                          |
//+------------------------------------------------------------------+
void CMasterWindows::Deinit()
   {
//--- 
   ObjectsDeleteAll(0,0,-1);
   Comment("");
   }
//+------------------------------------------------------------------+
//| OnTick() event processing method                                 |
//+------------------------------------------------------------------+
void CMasterWindows::OnEventTick()
   {
   if(on_event) // event processing is enabled
     {
     //---
     }
   }
//+------------------------------------------------------------------+
//| OnChartEvent() event processing method                           |
//+------------------------------------------------------------------+
void CMasterWindows::OnEvent(const int id,
                             const long &lparam,
                             const double &dparam,
                             const string &sparam)
  {
   if(on_event) // event processing is enabled
     {
     //---
     }
  }

3) La biblioteca de clases base y derivadas

La biblioteca puede contener cualquier cantidad de clases derivadas, y lo mejor es agruparlas en archivos separados, que se incluyen con la clase base (si la hay). De este modo, es más fácil hacer los cambios y adiciones necesarios, así como buscar los errores.

Así, ahora tenemos el marco de trabajo del programa. Pongámoslo a prueba y veamos si funciona correctamente: es momento de compilar y ejecutar. Si la prueba tiene éxito, podremos empezar a llenar el proyecto con módulos adicionales.

Empecemos con la conexión de clases derivadas, comenzando con las celdas:

Nombre de clase
Imagen
 Clase CCellText

 Clase CCellEdit

 Clase CCellButton

 Clase CCellButtonType

Tabla 1. Biblioteca de clases de celda

Echemos un vistazo detallado a la creación de una clase simple derivada de CCellButtonType. Esta clase crea botones de varios tipos.

//+------------------------------------------------------------------+
//| CCellButtonType class                                            |
//+------------------------------------------------------------------+
class CCellButtonType:public CCell
  {
public:
   ///Class constructor
   void              CCellButtonType();
   virtual     ///Draw method
   void              Draw(string m_name,
                          int m_xdelta,
                          int m_ydelta,
                          int m_type);
  };
//+------------------------------------------------------------------+
//| CCellButtonType class constructor                                |
//+------------------------------------------------------------------+
void CCellButtonType::CCellButtonType()
  {
   type=OBJ_BUTTON;
   on_event=false;   //disable events processing
  }
//+------------------------------------------------------------------+
//| CCellButtonType class Draw method                                |
//+------------------------------------------------------------------+
void CCellButtonType::Draw(string m_name,
                           int m_xdelta,
                           int m_ydelta,
                           int m_type)
  {
//--- creating an object with specified name
   if(m_type<=0) m_type=0;
   name=m_name+".Button"+(string)m_type;
   if(ObjectCreate(0,name,type,0,0,0,0,0)==false)
      Print("Function ",__FUNCTION__," error ",GetLastError());
//--- object properties initializartion
   ObjectSetInteger(0,name,OBJPROP_COLOR,Property.TextColor);
   ObjectSetInteger(0,name,OBJPROP_BGCOLOR,Property.BGColor);
   ObjectSetInteger(0,name,OBJPROP_CORNER,Property.Corner);
   ObjectSetInteger(0,name,OBJPROP_XDISTANCE,m_xdelta);
   ObjectSetInteger(0,name,OBJPROP_YDISTANCE,m_ydelta);
   ObjectSetInteger(0,name,OBJPROP_XSIZE,Property.H);
   ObjectSetInteger(0,name,OBJPROP_YSIZE,Property.H);
   ObjectSetInteger(0,name,OBJPROP_SELECTABLE,0);
   if(m_type==0) // Hide button
     {
      ObjectSetString(0,name,OBJPROP_TEXT,CharToString(MIN_WIN));
      ObjectSetString(0,name,OBJPROP_FONT,"Webdings");
      ObjectSetInteger(0,name,OBJPROP_FONTSIZE,12);
     }
   if(m_type==1) // Close button
     {
      ObjectSetString(0,name,OBJPROP_TEXT,CharToString(CLOSE_WIN));
      ObjectSetString(0,name,OBJPROP_FONT,"Wingdings 2");
      ObjectSetInteger(0,name,OBJPROP_FONTSIZE,8);
     }
   if(m_type==2) // Return button
     {
      ObjectSetString(0,name,OBJPROP_TEXT,CharToString(MAX_WIN));
      ObjectSetString(0,name,OBJPROP_FONT,"Webdings");
      ObjectSetInteger(0,name,OBJPROP_FONTSIZE,12);
     }
   if(m_type==3) // Plus button
     {
      ObjectSetString(0,name,OBJPROP_TEXT,"+");
      ObjectSetString(0,name,OBJPROP_FONT,"Arial");
      ObjectSetInteger(0,name,OBJPROP_FONTSIZE,10);
     }
   if(m_type==4) // Minus button
     {
      ObjectSetString(0,name,OBJPROP_TEXT,"-");
      ObjectSetString(0,name,OBJPROP_FONT,"Arial");
      ObjectSetInteger(0,name,OBJPROP_FONTSIZE,13);
     }
   if(m_type==5) // PageUp button
     {
      ObjectSetString(0,name,OBJPROP_TEXT,CharToString(PAGE_UP));
      ObjectSetString(0,name,OBJPROP_FONT,"Wingdings 3");
      ObjectSetInteger(0,name,OBJPROP_FONTSIZE,8);
     }
   if(m_type==6) // PageDown button
     {
      ObjectSetString(0,name,OBJPROP_TEXT,CharToString(PAGE_DOWN));
      ObjectSetString(0,name,OBJPROP_FONT,"Wingdings 3");
      ObjectSetInteger(0,name,OBJPROP_FONTSIZE,8);
     }
   if(m_type>6) // empty button
     {
      ObjectSetString(0,name,OBJPROP_TEXT,"");
      ObjectSetString(0,name,OBJPROP_FONT,"Arial");
      ObjectSetInteger(0,name,OBJPROP_FONTSIZE,13);
     }
   on_event=true;   //enable events processing
  }
//+------------------------------------------------------------------+

Explicaciones necesarias:

  • Introducimos una prohibición en el procesamiento de eventos en el constructor de clase. Esto es necesario para preparar el objeto para trabajar y eliminar las distracciones de futuros eventos. Tras completar todas las operaciones necesarias, permitiremos este procesamiento, y el objeto comenzará a funcionar debidamente.
  • El método de dibujo utiliza datos internos y recibe datos externos. Por tanto, los datos deberían ponerse a prueba primero para comprobar su cumplimiento, y solo se deberían procesar para evitar situaciones excepcionales. Pero no realizaremos esta prueba en este caso en particular. ¿Por qué? Imagínese que el objeto de clase es un soldado: los soldados no necesitan saber los planes de los generales. Su trabajo es cumplir las órdenes de sus comandantes de forma clara, rápida y rigurosa, en lugar de analizar los comandos recibidos y tomar decisiones independientes. Por tanto, todos los datos externos deben compilarse antes de empezar a trabajar con su clase.

Ahora debemos simular la biblioteca de celdas entera. Para ello, insertaremos el siguiente código en el módulo principal (temporalmente por motivos de simulación), y ejecutaremos el Asesor Experto.

//--- include file with classes
#include <ClassUnit.mqh>
//+------------------------------------------------------------------+
//| Main module: CMasterWindows class                                |
//+------------------------------------------------------------------+
class CMasterWindows
  {
protected:
   bool              on_event;   // events processing flag
   WinCell           Property;   // cell property
   CCellText         Text;
   CCellEdit         Edit;
   CCellButton       Button;
   CCellButtonType   ButtonType;
public:
   // Class constructor
   void              CMasterWindows();
   // Main module run method (core algorithm)
   void              Run();
   // Deinitialization method
   void              Deinit();
   // OnTick event processing method
   void              OnEventTick();
   // OnChart event processing method
   void              OnEvent(const int id,
                             const long &lparam,
                             const double &dparam,
                             const string &sparam);
  };
//+------------------------------------------------------------------+
//| Main module run method (core algorithm)                          |
//+------------------------------------------------------------------+
void CMasterWindows::Run()
  {
//--- core algorithm - it launches additional modules
   ObjectsDeleteAll(0,0,-1);
   Comment("MasterWindows for MQL5     © DC2008");
//--- Text field
   Text.Draw("Text",50,50,150,"Text field");
//--- Edit field
   Edit.Draw("Edit",205,50,150,"default value",true);
//--- LARGE BUTTON
   Button.Draw("Button",50,80,200,"LARGE BUTTON");
//--- Hide button
   ButtonType.Draw("type0",50,100,0);
//--- Close button
   ButtonType.Draw("type1",70,100,1);
//--- Return  button
   ButtonType.Draw("type2",90,100,2);
//--- Plus button
   ButtonType.Draw("type3",110,100,3);
//--- Minus button
   ButtonType.Draw("type4",130,100,4);
//--- None button
   ButtonType.Draw("type5",150,100,5);
//--- None button
   ButtonType.Draw("type6",170,100,6);
//--- None button
   ButtonType.Draw("type7",190,100,7);
//---
   on_event=true;   // enable events processing
  }

¡Y no debemos olvidarnos de transferir eventos para las clases resultantes! Si no se hace esto, manejar proyectos puede resultar muy difícil, o incluso imposible.

//+------------------------------------------------------------------+
//| CMasterWindows class OnChart event processing method             |
//+------------------------------------------------------------------+
void CMasterWindows::OnEvent(const int id,
                             const long &lparam,
                             const double &dparam,
                             const string &sparam)
  {
   if(on_event) // event processing is enabled
     {
      //--- process events for the cell class objects
      Text.OnEvent(id,lparam,dparam,sparam);
      Edit.OnEvent(id,lparam,dparam,sparam);
      Button.OnEvent(id,lparam,dparam,sparam);
      ButtonType.OnEvent(id,lparam,dparam,sparam);
     }
  }

Como resultado, veremos todas las opciones disponibles para objetos de la biblioteca de clases de celda.

Figura 2. Biblioteca de clases de celda

Figura 2. Biblioteca de clases de celda

Pongamos a prueba la eficiencia de funcionamiento y las respuestas de objetos a eventos:

  • Introducimos en el campo de edición diferentes variables en lugar de las que vienen "por defecto". Si los valores varían, eso significa que la simulación tuvo éxito.
  • Al pulsar los botones, permanecen pulsados hasta que se presionan de nuevo. Sin embargo, esta no es una reacción satisfactoria. Necesitamos que el botón vuelva a su estado original automáticamente tras apretarlo una vez. Y es aquí donde podemos demostrar el poder de la OOP: la posibilidad de la herencia. Nuestro programa puede usar más de una docena de botones, y no es necesario añadir la funcionalidad deseada para cada uno de ellos por separado. ¡Basta con cambiar la clase base CCell para que todos los objetos de las clases derivadas funcionen correctamente!
//+------------------------------------------------------------------+
//| CCell class OnChart event processing method                      |
//+------------------------------------------------------------------+
void CCell::OnEvent(const int id,
                    const long &lparam,
                    const double &dparam,
                    const string &sparam)
  {
   if(on_event) // event processing is enabled
     {
      //--- button click event
      if(id==CHARTEVENT_OBJECT_CLICK && StringFind(sparam,".Button",0)>0)
        {
         if(ObjectGetInteger(0,sparam,OBJPROP_STATE)==1)
           {
            //--- if button stays pressed
            Sleep(TIME_SLEEP);
            ObjectSetInteger(0,sparam,OBJPROP_STATE,0);
            ChartRedraw();
           }
        }
     }
  }

Por tanto, la biblioteca de clases de celda ya se ha puesto a prueba y se ha enlazado al proyecto.

El siguiente paso es añadir una biblioteca de líneas:

 Nombre de clase
Imagen
 Clase CRowType1 (0)

 Clase CRowType1 (1)

 Clase CRowType1 (2)

 Clase CRowType1 (3)

 Clase CRowType2

 Clase CRowType3

 Clase CRowType4

 Clase CRowType5

 Clase CRowType6

Tabla 2. Biblioteca de clases de línea

y la pondremos a prueba de la misma forma. Tras todas las simulaciones, procederemos a la siguiente fase.

2.4 4ª Fase: Construir el Proyecto

En este punto ya se han creado y simulado todos los módulos necesarios. Ahora procederemos a construir el proyecto. Primero crearemos una cascada en forma de ventana, como en la Figura 1, y la llenaremos con funcionalidad, es decir, reacciones programadas para todos los elementos y módulos de futuros eventos.

Para ello, tendremos listo un marco del programa y la preparación del módulo principal. Empezaremos con esto. Si es una de las clases "descendientes" de la clase base CWin, todos los métodos públicos y campos de la clase "antecesora" se pasaron a ella por herencia. Por tanto, simplemente debemos ajustar algunos métodos para tener lista una nueva clase CMasterWindows:

//--- include files with classes
#include <ClassWin.mqh>
#include <InitMasterWindows.mqh>
#include <ClassMasterWindowsEXE.mqh>
//+------------------------------------------------------------------+
//| CMasterWindows class                                             |
//+------------------------------------------------------------------+
class CMasterWindows:public CWin
  {
protected:
   CMasterWindowsEXE WinEXE;     // executable module
public:
   void              Run();      // Run method
   void              Deinit();   // Deinitialization method
   virtual                       // OnChart event processing method
   void              OnEvent(const int id,
                             const long &lparam,
                             const double &dparam,
                             const string &sparam);
  };
//+------------------------------------------------------------------+
//| CMasterWindows class deinitialization method                     |
//+------------------------------------------------------------------+
void CMasterWindows::Deinit()
  {
//---(delete all objects)
   ObjectsDeleteAll(0,0,-1);
   Comment("");
  }
//+------------------------------------------------------------------+
//| CMasterWindows class Run method                                  |
//+------------------------------------------------------------------+
void CMasterWindows::Run()
  {
   ObjectsDeleteAll(0,0,-1);
   Comment("MasterWindows for MQL5     © DC2008");
//--- creating designer window and launch executable object
   SetWin("CWin1",1,30,250,CORNER_RIGHT_UPPER);
   Draw(Mint,Mstr,21);
   WinEXE.Init("CWinNew",30,18);
   WinEXE.Run();
  }
//+------------------------------------------------------------------+
//| CMasterWindows class event processing method                     |
//+------------------------------------------------------------------+
void CMasterWindows::OnEvent(const int id,
                             const long &lparam,
                             const double &dparam,
                             const string &sparam)
  {
   if(on_event) // event processing is enabled
     {
      //--- Close button click in the main window
      if(id==CHARTEVENT_OBJECT_CLICK
         && StringFind(sparam,"CWin1",0)>=0
         && StringFind(sparam,".Button1",0)>0)
        {
         ExpertRemove();
        }
      //--- OnChart event processing for all objects
      STR1.OnEvent(id,lparam,dparam,sparam);
      STR2.OnEvent(id,lparam,dparam,sparam);
      STR3.OnEvent(id,lparam,dparam,sparam);
      STR4.OnEvent(id,lparam,dparam,sparam);
      STR5.OnEvent(id,lparam,dparam,sparam);
      STR6.OnEvent(id,lparam,dparam,sparam);
      WinEXE.OnEvent(id,lparam,dparam,sparam);
     }
  }

Por sí mismo, el módulo principal es bastante pequeño, puesto que no es responsable de nada más que de la creación de la ventana de aplicación. Después, el control pasa al módulo ejecutable WinEXE, en el que tiene lugar lo más interesante: la reacción a futuros eventos.

Anteriormente, creamos una estructura WinCell simple para el intercambio de datos entre objetos, y ahora se ven claramente todas las ventajas de este enfoque. El proceso de copiar todos los miembros de la estructura es muy racional y compacto:

   STR1.Property = Property;
   STR2.Property = Property;
   STR3.Property = Property;
   STR4.Property = Property;
   STR5.Property = Property;
   STR6.Property = Property;

En esta fase podemos terminar con la consideración detallada del diseño de clase y continuar con la tecnología visual de su construcción, que acelera considerablemente el proceso de crear nuevas clases.

3. Diseño visual de clases

Una clase se puede construir de forma mucho más rápida, y se puede visualizar mejor, en el módulo de diseño MasterWindows visual para MQL5:


Figura 3. El proceso de diseño visual

Figura 3. El proceso de diseño visual

Todo lo que se requiere del desarrollador es que dibuje el modelo de ventana usando el modelo MasterWindows, y después simplemente que determine la reacción al evento planeado. El código en sí mismo se crea de forma automática. ¡Y ya está! Hemos completado el proyecto.

En la Figura 4 se muestra un ejemplo de código generado de la clase CMasterWindows, así como del Asesor Experto (se crea un archivo en la carpeta ...\MQL5\Files):

//****** Project (Expert Advisor): project1.mq5
//+------------------------------------------------------------------+
//|        Code has been generated by MasterWindows Copyright DC2008 |
//|                                              http://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "DC2008"
//--- include files with classes
#include <ClassWin.mqh>
int Mint[][3]=
  {
     {1,0,0},
     {2,100,0},
     {1,100,0},
     {3,100,0},
     {4,100,0},
     {5,100,0},
     {6,100,50},
     {}
  };
string Mstr[][3]=
  {
     {"New window","",""},
     {"NEW1","new1",""},
     {"NEW2","new2",""},
     {"NEW3","new3",""},
     {"NEW4","new4",""},
     {"NEW5","new5",""},
     {"NEW6","new6",""},
     {}
  };
//+------------------------------------------------------------------+
//| CMasterWindows class (main unit)                                 |
//+------------------------------------------------------------------+
class CMasterWindows:public CWin
  {
private:
   long              Y_hide;          // Window shift vertical in hide mode
   long              Y_obj;           // Window shift vertical
   long              H_obj;           // Window shift horizontal
public:
   bool              on_hide;         // HIDE mode flag
   CArrayString      units;           // Main window lines
   void              CMasterWindows() {on_event=false; on_hide=false;}
   void              Run();           // Run method
   void              Hide();          // Hide method
   void              Deinit()         {ObjectsDeleteAll(0,0,-1); Comment("");}
   virtual void      OnEvent(const int id,
                             const long &lparam,
                             const double &dparam,
                             const string &sparam);
  };
//+------------------------------------------------------------------+
//| CMasterWindows class Run method                                  |
//+------------------------------------------------------------------+
void CMasterWindows::Run()
  {
   ObjectsDeleteAll(0,0,-1);
   Comment("Code has been generated by MasterWindows for MQL5 © DC2008");
//--- creating main window and launch executable module
   SetWin("project1.Exp",50,100,250,CORNER_LEFT_UPPER);
   Draw(Mint,Mstr,7);
  }
//+------------------------------------------------------------------+
//| CMasterWindows class Hide method                                 |
//+------------------------------------------------------------------+
void CMasterWindows::Hide()
  {
   Y_obj=w_ydelta;
   H_obj=Property.H;
   Y_hide=ChartGetInteger(0,CHART_HEIGHT_IN_PIXELS,0)-Y_obj-H_obj;;
//---
   if(on_hide==false)
     {
      int n_str=units.Total();
      for(int i=0; i<n_str; i++)
        {
         long y_obj=ObjectGetInteger(0,units.At(i),OBJPROP_YDISTANCE);
         ObjectSetInteger(0,units.At(i),OBJPROP_YDISTANCE,(int)y_obj+(int)Y_hide);
         if(StringFind(units.At(i),".Button0",0)>0)
            ObjectSetString(0,units.At(i),OBJPROP_TEXT,CharToString(MAX_WIN));
        }
     }
   else
     {
      int n_str=units.Total();
      for(int i=0; i<n_str; i++)
        {
         long y_obj=ObjectGetInteger(0,units.At(i),OBJPROP_YDISTANCE);
         ObjectSetInteger(0,units.At(i),OBJPROP_YDISTANCE,(int)y_obj-(int)Y_hide);
         if(StringFind(units.At(i),".Button0",0)>0)
            ObjectSetString(0,units.At(i),OBJPROP_TEXT,CharToString(MIN_WIN));
        }
     }
//---
   ChartRedraw();
   on_hide=!on_hide;
  }
//+------------------------------------------------------------------+
//| CMasterWindows class OnChartEvent event processing method        |
//+------------------------------------------------------------------+
void CMasterWindows::OnEvent(const int id,
                             const long &lparam,
                             const double &dparam,
                             const string &sparam)
  {
   if(on_event // event handling is enabled
      && StringFind(sparam,"project1.Exp",0)>=0)
     {
      //--- call of OnChartEvent handlers
      STR1.OnEvent(id,lparam,dparam,sparam);
      STR2.OnEvent(id,lparam,dparam,sparam);
      STR3.OnEvent(id,lparam,dparam,sparam);
      STR4.OnEvent(id,lparam,dparam,sparam);
      STR5.OnEvent(id,lparam,dparam,sparam);
      STR6.OnEvent(id,lparam,dparam,sparam);
      //--- creating graphic object
      if(id==CHARTEVENT_OBJECT_CREATE)
        {
         if(StringFind(sparam,"project1.Exp",0)>=0) units.Add(sparam);
        }
      //--- edit [NEW1] in Edit STR1
      if(id==CHARTEVENT_OBJECT_ENDEDIT
         && StringFind(sparam,".STR1",0)>0)
        {
        //--- event processing code
        }
      //--- edit [NEW3] : Plus button STR3
      if(id==CHARTEVENT_OBJECT_CLICK
         && StringFind(sparam,".STR3",0)>0
         && StringFind(sparam,".Button3",0)>0)
        {
        //--- event processing code
        }
      //--- edit [NEW3] : Minus button STR3
      if(id==CHARTEVENT_OBJECT_CLICK
         && StringFind(sparam,".STR3",0)>0
         && StringFind(sparam,".Button4",0)>0)
        {
        //--- event processing code
        }
      //--- edit [NEW4] : Plus button STR4
      if(id==CHARTEVENT_OBJECT_CLICK
         && StringFind(sparam,".STR4",0)>0
         && StringFind(sparam,".Button3",0)>0)
        {
        //--- event processing code
        }
      //--- edit [NEW4] : Minus button STR4
      if(id==CHARTEVENT_OBJECT_CLICK
         && StringFind(sparam,".STR4",0)>0
         && StringFind(sparam,".Button4",0)>0)
        {
        //--- event processing code
        }
      //--- edit [NEW4] : Up button STR4
      if(id==CHARTEVENT_OBJECT_CLICK
         && StringFind(sparam,".STR4",0)>0
         && StringFind(sparam,".Button5",0)>0)
        {
        //--- event processing code
        }
      //--- edit [NEW4] : Down button STR4
      if(id==CHARTEVENT_OBJECT_CLICK
         && StringFind(sparam,".STR4",0)>0
         && StringFind(sparam,".Button6",0)>0)
        {
        //--- event processing code
        }
      //--- [new5] button click STR5
      if(id==CHARTEVENT_OBJECT_CLICK
         && StringFind(sparam,".STR5",0)>0
         && StringFind(sparam,".Button",0)>0)
        {
        //--- event processing code
        }
      //--- [NEW6] button click STR6
      if(id==CHARTEVENT_OBJECT_CLICK
         && StringFind(sparam,".STR6",0)>0
         && StringFind(sparam,"(1)",0)>0)
        {
        //--- event processing code
        }
      //--- [new6] button click STR6
      if(id==CHARTEVENT_OBJECT_CLICK
         && StringFind(sparam,".STR6",0)>0
         && StringFind(sparam,"(2)",0)>0)
        {
        //--- event processing code
        }
      //--- button click [] STR6
      if(id==CHARTEVENT_OBJECT_CLICK
         && StringFind(sparam,".STR6",0)>0
         && StringFind(sparam,"(3)",0)>0)
        {
        //--- event processing code
        }
      //--- Close button click in the main window
      if(id==CHARTEVENT_OBJECT_CLICK
         && StringFind(sparam,".Button1",0)>0)
        {
         ExpertRemove();
        }
      //--- Hide button click in the main window
      if(id==CHARTEVENT_OBJECT_CLICK
         && StringFind(sparam,".Button0",0)>0)
        {
         Hide();
        }
     }
  }
//--- Main module declaration
CMasterWindows MasterWin;
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- launch main module
   MasterWin.Run();
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//--- main module deinitialization
   MasterWin.Deinit();
  }
//+------------------------------------------------------------------+
//| Expert Event function                                            |
//+------------------------------------------------------------------+
void OnChartEvent(const int id,
                  const long &lparam,
                  const double &dparam,
                  const string &sparam)
  {
//--- call OnChartEvent event handler
   MasterWin.OnEvent(id,lparam,dparam,sparam);
  }

Al ejecutar esto, veremos la siguiente ventana diseñada:

Figura 4. Advisor project1 - el resultado del diseño visual de clases

Figura 4. Asesor Experto project1 - el resultado del diseño visual de clases

Conclusión

  1. Las clases se deben diseñar paso a paso. Al dividir la tarea en módulos, se crea una clase separada para cada uno de ellos. Los módulos, a su vez, se dividen en micromódulos de clases base o derivadas.
  2. Trate de no sobrecargar las clases base con métodos incorporados: el número de estos se debe mantener al mínimo.
  3. El diseño de clases con el uso de un entorno de diseño visual es muy sencillo, incluso para "dummies", porque el código se genera automáticamente.

Localización de archivos adjuntos:

  • masterwindows.mq5 - ...\MQL5\Experts\
  • lo que queda en la carpeta - ...\MQL5\Include\

Traducción del ruso hecha por MetaQuotes Software Corp.
Artículo original: https://www.mql5.com/ru/articles/53

Archivos adjuntos |
Crear un Indicador con Buffers de Indicador Múltiples para Principiantes Crear un Indicador con Buffers de Indicador Múltiples para Principiantes

Los códigos complejos consisten en un conjunto de códigos sencillos. Si está familiarizado con ellos, no resulta tan complicado. En este artículo, consideraremos cómo crear un indicador con buffers de indicador múltiples. Como ejemplo se analizará en detalle el indicador Aroon y se presentarán dos versiones diferentes del código.

Widgets de las Señales Comerciales MetaTrader 4 y MetaTrader 5 Widgets de las Señales Comerciales MetaTrader 4 y MetaTrader 5

Desde hace poco, cada usuario MetaTrader 4 y MetaTrader 5 tiene la posibilidad de convertirse en suministrador de señales comerciales y obtener beneficios adicionales. Ahora, con la ayuda de los nuevos widgets puede hablar de sus éxitos en su propia página web, en un blog o en una página de la red social. Las ventajas del uso de los widgets son obvias: el aumento de la popularidad del suministrador, de su reputación como trader exitoso y la captación de nuevos suscriptores. Todo esto pueden obtener los traders que coloquen widgets en otras páginas de internet.

Algoritmos Genéticos: ¡Es fácil! Algoritmos Genéticos: ¡Es fácil!

En este artículo, el autor habla sobre cálculos evolucionarios con el uso de un algoritmo genético personalmente desarrollado. Demuestra el funcionamiento de un algoritmo, usando ejemplos, y facilita recomendaciones prácticas para su uso.

Un Ejemplo de Estrategia de Trading Basada en Diferencias de Zona Horaria en Continentes Distintos Un Ejemplo de Estrategia de Trading Basada en Diferencias de Zona Horaria en Continentes Distintos

Navegando por Internet es fácil encontrar muchas estrategias que le darán un buen número de recomendaciones diversas. Tomemos una punto de vista interno y observemos el proceso de la creación de estrategias basado en las diferentes zonas horarias en continentes distintos.