Extension de la bibliothèque standard MQL5 et réutilisation du code

MetaTrader 5 — Exemples | 13 janvier 2022, 08:52

326

[Supprimé]

Introduction

La bibliothèque standard MQL5 est un framework orienté objet composé d’un ensemble de classes prêtes à l’emploi qui vous facilite la vie en tant que développeur. Néanmoins, il ne met pas en œuvre tous les besoins de tous les développeurs du monde entier, donc si vous sentez que vous avez besoin de plus de choses personnalisées, vous pouvez aller plus loin et vous développer. Cet article vous explique l’intégration de l’indicateur technique Zig-Zag de MetaQuotes dans la bibliothèque standard. Nous nous inspirerons de la philosophie de conception de MetaQuotes afin d’atteindre notre objectif.

En un mot, l'API MQL5 est destinée à vous faire bénéficier de la réutilisation du code, de la fiabilité, de la flexibilité et de la facilité de maintenance. C’est ce que dit la théorie, mais au-delà de tout cela, si vous avez l'intention de continuer à progresser dans MQL5 et de développer des choses plus sophistiquées, telles que des Experts Advisors multi-devises, vous devez d'abord être capable de coder à la manière de la bibliothèque standard afin que vos applications soient garanties d'une vie réussie.

Plus vos EA et indicateurs deviennent complexes, plus il est nécessaire de maîtriser les concepts impliqués dans le développement d'un cadre. A titre d'exemple concret, c'est mon besoin personnel de développer un EA complexe multi-devises qui me dicte la nécessité de renforcer la base de mon projet à partir de zéro.

Figure 1. Les polyèdres réguliers sont des objets parfaits. Ils illustrent bien l’approche consistant à créer des applications sur des concepts solides.

Figure 1. Les polyèdres réguliers sont des objets parfaits. Ils décrivent bien l’approche de la création d’applications sur des concepts solides

1. ZigZag Télécharger

Nous commençons par télécharger l’indicateur ZigZag de MetaQuotes,disponible dans Code Base, à partir de notre terminal MetaTrader 5. Cela créera les fichiers Indicators\zigzag.mq5 et Indicators\zigzag.ex5.

Figure 2. Nous commençons à télécharger ZigZag de MetaQuotes à partir de notre terminal MetaTrader 5

Figure 2. Nous commençons à télécharger ZigZag de MetaQuotes à partir de notre terminal MetaTrader 5

J’attache ici ces lignes de Indicators\zigzag.mq5 contenant les paramètres d’entrée de l’indicateur, les variables globales et le gestionnaire OnInit(). Je n’ai mis cette partie que parce que le fichier entier a 298 lignes de code. C’est simplement pour la commodité et la compréhension de la vue d’ensemble dont nous parlons ci-dessous.

//+------------------------------------------------------------------+
//|                                                       ZigZag.mq5 |
//|                        Copyright 2009, MetaQuotes Software Corp. |
//|                                              https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "2009, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"
#property indicator_chart_window
#property indicator_buffers 3
#property indicator_plots   1
//---- plot Zigzag
#property indicator_label1  "Zigzag"
#property indicator_type1   DRAW_SECTION
#property indicator_color1  Red
#property indicator_style1  STYLE_SOLID
#property indicator_width1  1
//--- input parameters
input int      ExtDepth=12;
input int      ExtDeviation=5;
input int      ExtBackstep=3;
//--- indicator buffers
double         ZigzagBuffer[];      // main buffer
double         HighMapBuffer[];     // highs
double         LowMapBuffer[];      // lows
int            level=3;             // recounting depth
double         deviation;           // deviation in points
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- indicator buffers mapping
   SetIndexBuffer(0,ZigzagBuffer,INDICATOR_DATA);
   SetIndexBuffer(1,HighMapBuffer,INDICATOR_CALCULATIONS);
   SetIndexBuffer(2,LowMapBuffer,INDICATOR_CALCULATIONS);

//--- set short name and digits   
   PlotIndexSetString(0,PLOT_LABEL,"ZigZag("+(string)ExtDepth+","+(string)ExtDeviation+","+(string)ExtBackstep+")");
   IndicatorSetInteger(INDICATOR_DIGITS,_Digits);
//--- set empty value
   PlotIndexSetDouble(0,PLOT_EMPTY_VALUE,0.0);
//--- to use in cycle
   deviation=ExtDeviation*_Point;
//---
   return(INIT_SUCCEEDED);
  }

2. Vue d’ensemble rapide de haut en bas

Adoptons maintenant une approche descendante pour penser à notre nouvel indicateur ZigZag orienté objet que nous voulons intégrer dans la bibliothèque standard MQL5. Cela signifie que nous devons d’abord examiner l’ensemble du système, puis analyser les plus petites parties de celui-ci. Alors, pourquoi ne pas coder quelques EA factices afin de voir la situation dans son ensemble? Écrivons un Expert Advisor de style procédural avec sa version orientée objet.

2.1. ZigZag hors de la boîte

Les développeurs intermédiaires de MQL5 utiliseraient probablement l'indicateur ZigZag dans leurs EAs comme ceci :

//+----------------------------------------------------------------------+
//|                                            ExpertOriginalZigZag.mq5  |
//|                   Copyright © 2013, Laplacianlab - Jordi Bassagañas  | 
//+----------------------------------------------------------------------+
//--- EA properties
#property copyright     "Copyright © 2013, Laplacianlab - Jordi Bassagañas"
#property link          "https://www.mql5.com/fr/articles"
#property version       "1.00"
#property description   "This dummy Expert Advisor is just for showing how to use the original MetaQuotes' ZigZag indicator."
//--- EA inputs
input ENUM_TIMEFRAMES   EAPeriod=PERIOD_H1;
input string            CurrencyPair="EURUSD";
//--- global variables
int      zigZagHandle;
double   zigZagBuffer[];
double   zigZagHigh[];
double   zigZagLow[];
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   zigZagHandle=iCustom(CurrencyPair,EAPeriod,"zigzag",12,5,3);
   ArraySetAsSeries(zigZagBuffer,true);
   ArraySetAsSeries(zigZagHigh,true);
   ArraySetAsSeries(zigZagLow,true);  
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   IndicatorRelease(zigZagHandle);
   ArrayFree(zigZagBuffer);
   ArrayFree(zigZagHigh);
   ArrayFree(zigZagLow);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
   //--- refresh data   
   if(CopyBuffer(zigZagHandle,0,0,2,zigZagBuffer)<0)
   {
      Print("Can't copy ZigZag buffer 0!");
      return;
   }
   if(CopyBuffer(zigZagHandle,1,0,2,zigZagHigh)<0)
   {
      Print("Can't copy ZigZag buffer 1!");
      return;
   }
   if(CopyBuffer(zigZagHandle,2,0,2,zigZagLow)<0)
   {
      Print("Can't copy ZigZag buffer 2!");
      return;
   }
   //--- print values
   if(zigZagBuffer[0]!=0) Print("zigZagBuffer[0]: ", zigZagBuffer[0]);
   if(zigZagHigh[0]!=0) Print("zigZagHigh[0]: ", zigZagHigh[0]);
   if(zigZagLow[0]!=0) Print("zigZagLow[0]: ", zigZagLow[0]);
  }
//+------------------------------------------------------------------+

2.2. ZigZag intégré dans la bibliothèque standard

D’autre part, les développeurs MQL5 avancés voudront travailler avec l’indicateur ZigZag comme ils le font déjà avec les indicateurs de la bibliothèque standard, de cette façon :

//+----------------------------------------------------------------------+
//|                                                  ExpertOOZigZag.mq5  |
//|                   Copyright © 2013, Laplacianlab - Jordi Bassagañas  | 
//+----------------------------------------------------------------------+
#include <..\Include\Indicators\Custom\Trend.mqh>
//--- EA properties
#property copyright     "Copyright © 2013, Laplacianlab - Jordi Bassagañas"
#property link          "https://www.mql5.com/fr/articles"
#property version       "1.00"
#property description   "This dummy Expert Advisor is just for showing how to use the object-oriented version of MetaQuotes' ZigZag indicator."
//--- EA inputs
input ENUM_TIMEFRAMES   EAPeriod=PERIOD_H1;
input string            CurrencyPair="EURUSD";
//--- global variables
CiZigZag *ciZigZag;
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   ciZigZag=new CiZigZag;
   ciZigZag.Create(CurrencyPair,EAPeriod,12,5,3);
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   delete(ciZigZag);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {   
   //--- refresh data
   ciZigZag.Refresh();
   //--- print values
   if(ciZigZag.ZigZag(0)!=0) Print("OO ZigZag buffer: ", ciZigZag.ZigZag(0));
   if(ciZigZag.High(0)!=0) Print("OO ZigZag high: ", ciZigZag.High(0));
   if(ciZigZag.Low(0)!=0) Print("OO ZigZag low: ",ciZigZag.Low(0));
  }
//+------------------------------------------------------------------+

2.3. Conclusion

La deuxième solution est meilleure car elle est orientée objet. Une fois les classes OO développées, il est intuitif d’observer qu’il est beaucoup plus facile d’interagir avec la fonctionnalité orientée objet du Zig-Zag que de travailler avec son homologue procédural. Rappelons brièvement, cependant, les avantages dont nous bénéficions lorsque nous travaillons avec une bibliothèque orientée objet :

La POO facilite la modéliser les problèmes.
La POO facilite la réutilisation du code, ce qui profite au coût, à la fiabilité, à la flexibilité et à la maintenance.
Ce paradigme permet la création d’ADTAbstract Data Types). Un ADT est une abstraction du concept traditionnel de type de données, qui est présent dans tous les langages de programmation.

Figure 3. Icosaèdre régulier. Construire nos applications sur des concepts solides est une garantie de qualité qui fait que nos conceptions persistent dans le temps

3. Intégration de notre nouveau ZigZag OO dans la bibliothèque standard MQL5

Comme je l’ai dit dans l’introduction de cet article, nous nous inspirons du style orienté objet de MetaQuotes pour construire notre nouvel ensemble de classes destinées à envelopper le ZigZag téléchargé précédemment. C’est facile, il suffit de jeter un coup d’œil aux fichiers à l’intérieur d’Include\Indicators et d’étudier et de comprendre certaines des idées qui se cachent derrière la bibliothèque standard MQL5. Lorsque vous regardez ce qu’il y a à l’intérieur de Trend.mqh de MetaQuotes, vous vous rendrez vite compte qu’il est plein de classes représentant certains indicateurs techniques: ADX, bandes de Bollinger, SAR, moyennes mobiles, etc. Toutes ces classes héritent de CIndicator. Mettons donc en œuvre ce schéma. D'ailleurs, l’extension du nouvel indicateur OO de la classe CiCustom de MQL5 aurait été une autre alternative pour mettre en œuvre cet exercice.

Commençons par créer le nouveau dossier Include\Indicators\Custom et, juste après, le nouveau fichier Include\Indicators\Custom\Trend.mqh afin que nous puissions y coder nos propres indicateurs techniques, tout comme MetaQuotes le fait dans son Include\Indicators\Trend.mqh. Voici notre fichier d’extension Include\Indicators\Custom\Trend.mqh déjà implémenté. Je vais discuter ci-dessous de certains aspects techniques nécessaires pour le coder.

//+------------------------------------------------------------------+
//|                              Include\Indicators\Custom\Trend.mqh |
//|                  Copyright 2013, Laplacianlab - Jordi Bassagañas |
//|                     https://www.mql5.com/en/users/laplacianlab |
//+------------------------------------------------------------------+
#include <..\Include\Indicators\Indicator.mqh>
//+------------------------------------------------------------------+
//| Class CiZigZag.                                                  |
//| Purpose: Class of the "ZigZag" indicator.                        |
//|          Derives from class CIndicator.                          |
//+------------------------------------------------------------------+
class CiZigZag : public CIndicator
  {
protected:
   int               m_depth;
   int               m_deviation;
   int               m_backstep;

public:
                     CiZigZag(void);
                    ~CiZigZag(void);
   //--- methods of access to protected data
   int               Depth(void)          const { return(m_depth);      }
   int               Deviation(void)      const { return(m_deviation);  }
   int               Backstep(void)       const { return(m_backstep);   }
   //--- method of creation
   bool              Create(const string symbol,const ENUM_TIMEFRAMES period,
                            const int depth,const int deviation_create,const int backstep);
   //--- methods of access to indicator data
   double            ZigZag(const int index) const;
   double            High(const int index) const;
   double            Low(const int index) const;
   //--- method of identifying
   virtual int       Type(void) const { return(IND_CUSTOM); }

protected:
   //--- methods of tuning
   virtual bool      Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int num_params,const MqlParam &params[]);
   bool              Initialize(const string symbol,const ENUM_TIMEFRAMES period,
                                const int depth,const int deviation_init,const int backstep);
  };
//+------------------------------------------------------------------+
//| Constructor                                                      |
//+------------------------------------------------------------------+
CiZigZag::CiZigZag(void) : m_depth(-1),
                         m_deviation(-1),
                         m_backstep(-1)
  {
  }
//+------------------------------------------------------------------+
//| Destructor                                                       |
//+------------------------------------------------------------------+
CiZigZag::~CiZigZag(void)
  {
  }
//+------------------------------------------------------------------+
//| Create indicator "Zig Zag"                                       |
//+------------------------------------------------------------------+
bool CiZigZag::Create(const string symbol,const ENUM_TIMEFRAMES period,
                      const int depth,const int deviation_create,const int backstep)
  {
//--- check history
   if(!SetSymbolPeriod(symbol,period))
      return(false);
//--- create
   m_handle=iCustom(symbol,period,"zigzag",depth,deviation_create,backstep);
//--- check result
   if(m_handle==INVALID_HANDLE)
      return(false);
//--- indicator successfully created
   if(!Initialize(symbol,period,depth,deviation_create,backstep))
     {
      //--- initialization failed
      IndicatorRelease(m_handle);
      m_handle=INVALID_HANDLE;
      return(false);
     }
//--- ok
   return(true);
  }
//+------------------------------------------------------------------+
//| Initialize the indicator with universal parameters               |
//+------------------------------------------------------------------+
bool CiZigZag::Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int num_params,const MqlParam &params[])
  {
   return(Initialize(symbol,period,(int)params[0].integer_value,(int)params[1].integer_value,(int)params[2].integer_value));
  }
//+------------------------------------------------------------------+
//| Initialize indicator with the special parameters                 |
//+------------------------------------------------------------------+
bool CiZigZag::Initialize(const string symbol,const ENUM_TIMEFRAMES period,
                        const int depth,const int deviation_init,const int backstep)
  {
   if(CreateBuffers(symbol,period,3))
     {
      //--- string of status of drawing
      m_name  ="ZigZag";
      m_status="("+symbol+","+PeriodDescription()+","+
               IntegerToString(depth)+","+IntegerToString(deviation_init)+","+
               IntegerToString(backstep)+") H="+IntegerToString(m_handle);
      //--- save settings
      m_depth=depth;
      m_deviation=deviation_init;
      m_backstep=backstep;       
      //--- create buffers
      ((CIndicatorBuffer*)At(0)).Name("ZIGZAG");
      ((CIndicatorBuffer*)At(1)).Name("HIGH");
      ((CIndicatorBuffer*)At(2)).Name("LOW");
      //--- ok
      return(true);
     }
//--- error
   return(false);
  }
//+------------------------------------------------------------------+
//| Access to ZigZag buffer of "Zig Zag"                             |
//+------------------------------------------------------------------+
double CiZigZag::ZigZag(const int index) const
  {
   CIndicatorBuffer *buffer=At(0);
//--- check
   if(buffer==NULL)
      return(EMPTY_VALUE);
//---
   return(buffer.At(index));
  }
//+------------------------------------------------------------------+
//| Access to High buffer of "Zig Zag"                               |
//+------------------------------------------------------------------+
double CiZigZag::High(const int index) const
  {
   CIndicatorBuffer *buffer=At(1);
//--- check
   if(buffer==NULL)
      return(EMPTY_VALUE);
//---
   return(buffer.At(index));
  }
//+------------------------------------------------------------------+
//| Access to Low buffer of "Zig Zag"                                |
//+------------------------------------------------------------------+
double CiZigZag::Low(const int index) const
  {
   CIndicatorBuffer *buffer=At(2);
//--- check
   if(buffer==NULL)
      return(EMPTY_VALUE);
//---
   return(buffer.At(index));
  }
//+------------------------------------------------------------------+

3.1. Encapsulation orientée objet

L’encapsulation OO est une bonne pratique de programmation, ce qui signifie que les données membres des objets ne peuvent être modifiées que par les opérations définies pour eux. Toutes les classes définies dans Trend.mqh de MetaQuotes implémentent cette idée, nous faisons donc de même.

D’une part, il existe les propriétés protégées spécifiques de CiZigZag :

protected:
   int               m_depth;
   int               m_deviation;
   int               m_backstep;

Par la suite, il existe l’interface publique de CiZigZag permettant d’accéder depuis l’extérieur d’un objet donné de type CiZigZag aux propriétés protégées définies ci-dessus :

public:
   //--- methods of access to protected data
   int               Depth(void)          const { return(m_depth);      }
   int               Deviation(void)      const { return(m_deviation);  }
   int               Backstep(void)       const { return(m_backstep);   }

Il s’agit d’une mesure de sécurité permettant d’isoler des objets. Cette encapsulation protège contre les modifications arbitraires effectuées par quelqu’un ou quelque chose qui n’est pas autorisé à accéder aux données des objets.

3.2. Accès aux données de ZigZag

Comme indiqué dans la première section de cet article, le fichier de code source nommé zigzag.mq5 crée trois tampons :

//--- indicator buffers mapping
   SetIndexBuffer(0,ZigzagBuffer,INDICATOR_DATA);
   SetIndexBuffer(1,HighMapBuffer,INDICATOR_CALCULATIONS);
   SetIndexBuffer(2,LowMapBuffer,INDICATOR_CALCULATIONS);

Grâce à l'encapsulation orientée objet, les méthodes de CiZigZag ZigZag(const int index) , High(const int index) et Low(const int index) renvoient les tampons indicateurs qui ont été créés au préalable dans la méthode d'initialisation. Il est important de noter que le wrapper orienté objet CIndicatorBuffer est défini dans la classe de MQL5 Include\Indicators\Indicator.mqh. CIndicatorBuffer est l’élément central de ces trois méthodes. Nous sommes déjà immergés dans l’API MQL5 !

À titre d’exemple ici, c’est le code pour accéder au tampon élevé de CiZigZag :

//+------------------------------------------------------------------+
//| Access to High buffer of "Zig Zag"                               |
//+------------------------------------------------------------------+
double CiZigZag::High(const int index) const
  {
   CIndicatorBuffer *buffer=At(1);
//--- check
   if(buffer==NULL)
      return(EMPTY_VALUE);
//---
   return(buffer.At(index));
  }

3.3. Polymorphisme, surcharge de méthode et fonctions virtuelles

Dans la section précédente, nous avons brièvement abordé le sujet de l’encapsulation qui est l’une des caractéristiques les plus importantes de la programmation orientée objet. Eh bien, les classes contenues dans Include\Indicators\Indicator.mqh et le fichier Include\Indicators\Custom\Trend.mqh traitent de deux autres aspects du paradigme de la POO, le polymorphisme et la surcharge de méthode.

Le polymorphisme a la capacité d’accéder à un large éventail de méthodes via la même interface. De cette façon, un identifiant donné peut prendre plusieurs formes en fonction du contexte dans lequel il se trouve. Le polymorphisme nécessite le mécanisme d’héritage pour pouvoir être implémenté. D’autre part, la surcharge de méthode est une autre fonctionnalité de POO qui permet de créer plusieurs méthodes partageant le même nom mais avec des déclarations de paramètres différentes.

Ceci est une très courte introduction. Il n’y a pas assez d’espace dans cet article pour discuter de ces sujets, alors les approfondir est un exercice qui vous reste. S’il vous plaît, lisez les sections MQL5 Polymorphisme et Surcharge. Dans tous les cas, nous voyons la bibliothèque standard implémenter toutes les fonctionnalités de POO, par conséquent, mieux nous les connaissons, mieux nous pouvons étendre l’API pour répondre à nos besoins.

Avec tout ce qui a été dit, il n’y a plus qu’une chose à noter. MQL5 implémente le polymorphisme par un mécanisme appelé Fonctions virtuelles. Encore une fois, veuillez lire la section MQL5 Fonctions virtuelles pour comprendre comment cela fonctionne.

C’est pourquoi nous codons la méthode d’initialisation de CiZigZagde cette façon:

//+------------------------------------------------------------------+
//| Initialize the indicator with universal parameters               |
//+------------------------------------------------------------------+
bool CiZigZag::Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int num_params,const MqlParam &params[])
  {
   return(Initialize(symbol,period,(int)params[0].integer_value,(int)params[1].integer_value,(int)params[2].integer_value));
  }
//+------------------------------------------------------------------+
//| Initialize indicator with the special parameters                 |
//+------------------------------------------------------------------+
bool CiZigZag::Initialize(const string symbol,const ENUM_TIMEFRAMES period,
                        const int depth,const int deviation_init,const int backstep)
  {
   if(CreateBuffers(symbol,period,3))
     {
      //--- string of status of drawing
      m_name  ="ZigZag";
      m_status="("+symbol+","+PeriodDescription()+","+
               IntegerToString(depth)+","+IntegerToString(deviation_init)+","+
               IntegerToString(backstep)+") H="+IntegerToString(m_handle);
      //--- save settings
      m_depth=depth;
      m_deviation=deviation_init;
      m_backstep=backstep;       
      //--- create buffers
      ((CIndicatorBuffer*)At(0)).Name("ZIGZAG");
      ((CIndicatorBuffer*)At(1)).Name("HIGH");
      ((CIndicatorBuffer*)At(2)).Name("LOW");
      //--- ok
      return(true);
     }
//--- error
   return(false);
  }

4. Test du nouveau ZigZag OO, déjà disponible dans la bibliothèque standard

Bien sûr, avant d’utiliser les extensions développées par vous dans vos développements OO, vous devez d’abord vous assurer qu’elles fonctionnent comme prévu. Il est recommandé d’exécuter un ensemble complet de tests sur vos nouveaux composants personnalisés. Pour des questions de simplicité, cependant, nous allons maintenant exécuter un test simple sur les trois méthodes principales de CiZigZag, c’est-à-dire ZigZag (const int index), High(const int index) et Low (const int index).

Nous allons simplement imprimer les valeurs calculées par ces trois méthodes sur chaque tick d’EA, puis comparer la sortie générée par ExpertOriginalZigZag.ex5, l’EA procédural factice, avec la sortie générée par ExpertOOZigZag.ex5, l’EA factice orienté objet. Chaque fois que les deux sorties obtenues sont les mêmes, nous pouvons conclure que la nouvelle extension est OK, nous pouvons prendre pour bon notre ZigZag OO intégré dans l’API MQL5.

Figure 4. Nous comparons la sortie générée par ExpertOriginalZigZag.ex5 avec la sortie générée par ExpertOOZigZag.ex5

Figure 4. Nous comparons la sortie générée par ExpertOriginalZigZag.ex5 avec la sortie générée par ExpertOOZigZag.ex5

Par conséquent, nous exécutons à la fois ExpertOriginalZigZag.ex5 et ExpertOOZigZag.ex5, les deux EA présentés au début de cet article, dans le testeur de stratégie avec les paramètres suivants définis :

Symbole : EURUSD, H1
Date : Période personnalisée, du 2013.08.01 au 2013.08.15
Exécution : Normal, 1 Minute OHLC
Dépôt : 10000 USD, 1:100
Optimization : Aucun

Comme les deux robots impriment les mêmes résultats, nous concluons que notre CiZigZag est bien implémenté, nous pouvons donc l’utiliser dans nos développements à partir de maintenant.

Journal généré par ExpertOriginalZigZag.ex5:

DE      0       18:45:39        ExpertOriginalZigZag (EURUSD,H1)        2013.08.01 08:50:40   zigZagBuffer[0]: 1.32657
ML      0       18:45:39        ExpertOriginalZigZag (EURUSD,H1)        2013.08.01 08:50:40   zigZagLow[0]: 1.32657
FL      0       18:45:39        ExpertOriginalZigZag (EURUSD,H1)        2013.08.01 08:50:59   zigZagBuffer[0]: 1.32657
GE      0       18:45:39        ExpertOriginalZigZag (EURUSD,H1)        2013.08.01 08:50:59   zigZagLow[0]: 1.32657
KS      0       18:45:39        ExpertOriginalZigZag (EURUSD,H1)        2013.08.01 08:51:00   zigZagBuffer[0]: 1.32657
FR      0       18:45:39        ExpertOriginalZigZag (EURUSD,H1)        2013.08.01 08:51:00   zigZagLow[0]: 1.32657
GK      0       18:45:39        ExpertOriginalZigZag (EURUSD,H1)        2013.08.01 08:51:20   zigZagBuffer[0]: 1.32653
RJ      0       18:45:39        ExpertOriginalZigZag (EURUSD,H1)        2013.08.01 08:51:20   zigZagLow[0]: 1.32653
OR      0       18:45:39        ExpertOriginalZigZag (EURUSD,H1)        2013.08.01 08:51:40   zigZagBuffer[0]: 1.32653
FS      0       18:45:39        ExpertOriginalZigZag (EURUSD,H1)        2013.08.01 08:51:40   zigZagLow[0]: 1.32653
QJ      0       18:45:39        ExpertOriginalZigZag (EURUSD,H1)        2013.08.01 08:51:59   zigZagBuffer[0]: 1.32653
PH      0       18:45:39        ExpertOriginalZigZag (EURUSD,H1)        2013.08.01 08:51:59   zigZagLow[0]: 1.32653
JQ      0       18:45:39        ExpertOriginalZigZag (EURUSD,H1)        2013.08.01 08:52:00   zigZagBuffer[0]: 1.32653
KP      0       18:45:39        ExpertOriginalZigZag (EURUSD,H1)        2013.08.01 08:52:00   zigZagLow[0]: 1.32653
RH      0       18:45:39        ExpertOriginalZigZag (EURUSD,H1)        2013.08.01 08:52:20   zigZagBuffer[0]: 1.32653
GI      0       18:45:39        ExpertOriginalZigZag (EURUSD,H1)        2013.08.01 08:52:20   zigZagLow[0]: 1.32653
GP      0       18:45:39        ExpertOriginalZigZag (EURUSD,H1)        2013.08.01 08:52:40   zigZagBuffer[0]: 1.32614
// More data here!..

Journal généré par ExpertOOZigZag.ex5 :

RP      0       18:48:02        ExpertOOZigZag (EURUSD,H1)      2013.08.01 08:50:40   OO ZigZag buffer(0): 1.32657
HQ      0       18:48:02        ExpertOOZigZag (EURUSD,H1)      2013.08.01 08:50:40   OO ZigZag low(0): 1.32657
DI      0       18:48:02        ExpertOOZigZag (EURUSD,H1)      2013.08.01 08:50:59   OO ZigZag buffer(0): 1.32657
RH      0       18:48:02        ExpertOOZigZag (EURUSD,H1)      2013.08.01 08:50:59   OO ZigZag low(0): 1.32657
QR      0       18:48:02        ExpertOOZigZag (EURUSD,H1)      2013.08.01 08:51:00   OO ZigZag buffer(0): 1.32657
GS      0       18:48:02        ExpertOOZigZag (EURUSD,H1)      2013.08.01 08:51:00   OO ZigZag low(0): 1.32657
IK      0       18:48:02        ExpertOOZigZag (EURUSD,H1)      2013.08.01 08:51:20   OO ZigZag buffer(0): 1.32653
GJ      0       18:48:02        ExpertOOZigZag (EURUSD,H1)      2013.08.01 08:51:20   OO ZigZag low(0): 1.32653
EL      0       18:48:02        ExpertOOZigZag (EURUSD,H1)      2013.08.01 08:51:40   OO ZigZag buffer(0): 1.32653
OD      0       18:48:02        ExpertOOZigZag (EURUSD,H1)      2013.08.01 08:51:40   OO ZigZag low(0): 1.32653
OE      0       18:48:02        ExpertOOZigZag (EURUSD,H1)      2013.08.01 08:51:59   OO ZigZag buffer(0): 1.32653
IO      0       18:48:02        ExpertOOZigZag (EURUSD,H1)      2013.08.01 08:51:59   OO ZigZag low(0): 1.32653
DN      0       18:48:02        ExpertOOZigZag (EURUSD,H1)      2013.08.01 08:52:00   OO ZigZag buffer(0): 1.32653
RF      0       18:48:02        ExpertOOZigZag (EURUSD,H1)      2013.08.01 08:52:00   OO ZigZag low(0): 1.32653
PP      0       18:48:02        ExpertOOZigZag (EURUSD,H1)      2013.08.01 08:52:20   OO ZigZag buffer(0): 1.32653
RQ      0       18:48:02        ExpertOOZigZag (EURUSD,H1)      2013.08.01 08:52:20   OO ZigZag low(0): 1.32653
MI      0       18:48:02        ExpertOOZigZag (EURUSD,H1)      2013.08.01 08:52:40   OO ZigZag buffer(0): 1.32614
// More data here!..

Conclusion

Bibliothèque standard MQL5 vous facilite la vie en tant que développeur. Néanmoins, il ne peut pas mettre en œuvre tous les besoins de tous les développeurs du monde entier, il y aura donc toujours un moment où vous devrez créer vos éléments personnalisés. Au fur et à mesure que vos EA et indicateurs deviennent de plus en plus complexes, il est de plus en plus nécessaire de maîtriser les concepts impliqués dans l’élaboration d’un cadre. L’extension de la bibliothèque standard MQL5 est une garantie de qualité pour que vos applications aient une vie réussie.

Nous avons tiré parti de la réutilisation du code en téléchargeant d’abord l’indicateur ZigZag à partir de Code Base. Une fois disponible dans notre terminal MetaTrader 5, nous avons adopté une approche descendante afin de commencer à penser à notre nouvel indicateur ZigZag orienté objet. Nous avons examiné de manière générale l’ensemble du système, puis nous avons poursuivi l’analyse. Dans la première phase du développement, nous avons comparé un EA factice utilisant l’indicateur ZigZag de style procédural avec son homologue orienté objet.

Nous avons enveloppé l’indicateur ZigZag dans une classe orientée objet qui a été conçue selon la philosophie de conception de MetaQuotes, la même chose s’appliquant à la construction de la bibliothèque standard. Enfin, nous avons effectué quelques tests simples pour conclure que notre nouveau wrapper CiZigZag, déjà intégré à l’API MQL5, est bien implémenté.

Traduit de l’anglais par MetaQuotes Ltd.
Article original : https://www.mql5.com/en/articles/741

Fichiers joints |

Télécharger ZIP

expertoriginalzigzag.mq5 (2.54 KB)

expertoozigzag.mq5 (2.03 KB)

trend.mqh (6.34 KB)

zigzag.mq5 (9.34 KB)

Avertissement: Tous les droits sur ces documents sont réservés par MetaQuotes Ltd. La copie ou la réimpression de ces documents, en tout ou en partie, est interdite.

Autres articles par cet auteur

Aller à la discussion

Le MQL5 Cookbook : Enregistrement des résultats d'optimisation d'un Expert Advisor sur la base de critères spécifiés

Nous continuons la série d'articles sur la programmation MQL5. Cette fois, nous verrons comment obtenir les résultats de chaque passe d'optimisation lors de l'optimisation des paramètres de l'Expert Advisor. La mise en œuvre sera effectuée de manière à garantir que si les conditions spécifiées dans les paramètres externes sont remplies, les valeurs de passage correspondantes seront écrites dans un fichier. En plus des valeurs de test, nous enregistrerons également les paramètres qui ont conduit à de tels résultats.

Résultats du MetaTrader AppStore pour le troisième trimestre 2013

Un autre trimestre de l'année s'est écoulé et nous avons décidé de résumer ses résultats pour MetaTrader AppStore - le plus grand magasin de robots de trading et d'indicateurs techniques pour les plateformes MetaTrader. Plus de 500 développeurs ont placé plus de 1 200 produits sur Market à la fin du trimestre considéré.

Le MQL5 Cookbook : Notifications sonores pour les événements de trading MetaTrader 5

Dans cet article, nous examinerons des problèmes tels que l'inclusion de fichiers sonores dans le fichier de l'Expert Advisor, et ainsi l'ajout de notifications sonores aux événements de trading. Le fait que les fichiers seront inclus signifie que les fichiers sonores seront situés à l'intérieur de l'Expert Advisor. Ainsi, lorsque vous donnez la version compilée de l'Expert Advisor (*.ex5) à un autre utilisateur, vous n'aurez pas à fournir également les fichiers sonores et à expliquer où ils doivent être sauvegardés.

Comment gagner de l'argent avec l'AppStore de MetaTrader et les services de signaux de trading si vous n'êtes pas un vendeur ou un fournisseur

Il est possible de commencer à gagner de l'argent sur MQL5.com dès maintenant sans avoir à être un vendeur d'applications Market ou un fournisseur de signaux rentable. Sélectionnez les produits que vous aimez et publiez des liens vers eux sur diverses ressources Web. Attirez des clients potentiels et faites des bénéfices !