Comprendre la Programmation Orientée Objet (POO) MQL5

Introduction

Dans cet article, nous allons partager l'un des sujets les plus importants de la programmation qui permet de coder facilement et en douceur, et qui nous aide à appliquer le concept DRY (Do Not Repeat Yourself, Ne Vous Répétez Pas en français) en tant que développeurs ou programmeurs. En plus de renforcer la sécurité de tout logiciel créé, et d'autres caractéristiques. Nous parlerons de la Programmation Orientée Objet (POO) et de la manière dont nous pouvons utiliser ce concept et le coder dans MQL5 (MetaQuotes Language) en comprenant d'abord les bases de la POO, puis en comprenant comment l'utiliser dans MQL5 à l'aide de quelques applications.

Nous allons donc aborder ce sujet intéressant et important à travers les 3 points suivants :

• Qu'est-ce que la POO ?
• La POO dans MQL5
• Applications POO
• Conclusion

L'objectif principal de cet article est de comprendre les bases de la Programmation Orientée Objet (POO) en général et comment elle peut être utile dans la création de logiciels. Ensuite, nous apprendrons comment appliquer cette approche dans MQL5 pour créer des logiciels plus efficaces et plus sûrs en appliquant cette approche incroyable.

Elle sera très utile à quiconque désireux d'en apprendre davantage sur cette approche de POO. Il existe des ressources très importantes et informatives sur cette approche en général, d'autant plus qu'elle est applicable à d'autres langages de programmation tels que C++, Java, Python et d'autres. Dans le langage MQL5, il existe une ressource très importante, non seulement pour notre article, mais aussi pour tous les sujets du langage MQL5 : la documentation MQL5. Vous pouvez consulter le sujet de la POO en cliquant sur le lien Documentation POO MQL5.

Avertissement : Toutes les informations données dans cet article sont fournies "en l'état", uniquement à des fins d'information et ne sont aucunement données à des fins de trading ou de conseil. Ces informations ne garantissent aucun type de résultat. Si vous utilisez le contenu de cet article sur l'un de vos comptes de trading, vous le faites à vos propres risques et vous en serez le seul responsable.

Qu'est-ce que la POO ?

Dans ce sujet, nous apprendrons les bases de la POO en général. Commençons donc ce sujet intéressant par la définition de la POO. Elle permet de créer et de développer des logiciels réutilisables en douceur, sans duplication du travail et du code, ce qui nous aide à appliquer le concept DRY (Do not Repeat Yourself, Ne Vous Répétez Pas en français).

Comme nous le verrons, la POO nous aide à nous rapprocher de la nature du monde, car tout ce qui nous entoure est créé par des objets et chacun d'eux a sa nature et son comportement. C'est ce que nous pouvons faire avec nos données dans le logiciel. Si nous voulons nous plonger davantage dans la POO, nous devons savoir que nous aurons affaire à des objets et à des classes, l'objet étant une instance d'une classe et la classe étant un modèle pour l'objet. À l'intérieur du modèle qui est la classe, nous définissons le comportement de cet objet en détail.

Concepts de base de la POO

Lorsque nous appliquons la méthode POO aux logiciels, les principes suivants sont appliqués :

1. Encapsulation
2. Abstraction
3. Héritage
4. Polymorphisme

1- Encapsulation

L'encapsulation est la méthode qui permet de lier des fonctions et des données dans une classe. Les données et les fonctions de la classe peuvent être privées, c'est-à-dire accessibles uniquement à l'intérieur de la classe, ou publiques, c'est-à-dire accessibles à l'extérieur de la classe. Le concept d'encapsulation permet de masquer la complexité de l'implémentation de la classe et donne au développeur le contrôle total de ses données, en l'aidant à garder la trace de toutes les valeurs qui dépendent d'autres valeurs sans conflit.

Nous pouvons donc dire que l'encapsulation aide à maintenir notre système opérationnel et à éviter un grand nombre d'erreurs possibles, tout en offrant un niveau élevé de contrôle au développeur et en aidant à tester et à traiter les données des classes de manière plus fluide et plus facile sans affecter ou modifier l'ensemble du code du logiciel. D'après ce qui a été dit, l’encapsulation permet également de résoudre les erreurs et d'éviter de compliquer le code.

L'image suivante représente le concept d'encapsulation :

2- Abstraction

L'abstraction est la méthode qui consiste à cacher les détails inutiles et à ne présenter que les détails essentiels. Elle est plus large que le concept d'encapsulation, mais elle permet d'atteindre le même objectif de protection des données et de mise en œuvre des fonctions sans tout savoir sur le processus de mise en œuvre de toutes les classes, mais en sachant seulement ce qu'il faut faire pour que la mise en œuvre soit effectuée.

Pour ce faire, nous devons inclure deux méthodes importantes : l'interface et l'implémentation. L'interface est la méthode qui permet aux classes d'interagir et de traiter avec les autres, et l'implémentation est la méthode qui contient tous les détails du code ou de la logique des classes. L'abstraction permet donc d'améliorer la sécurité du logiciel et de ne pas répéter notre processus de codage ou de recoder à partir de zéro, mais seulement de développer et de coder d'autres applications sur la base de celle qui a été bien créée.

3- Héritage

D'après son nom, le concept d'héritage signifie que nous dérivons une nouvelle classe d'une ancienne et que la nouvelle hérite des caractéristiques de l'ancienne. Dans ce cas, l'ancienne classe est appelée parent ou superclasse et la nouvelle classe dérivée est appelée classe enfant. Ce concept permet d'appliquer le concept DRY (Do not Repeat Yourself) et fournit l'idée principale de la réutilisabilité.

4- Polymorphisme

D'après le nom de ce concept, si nous divisons le mot en deux segments, nous trouverons que Poly signifie plusieurs ou multiples et Morphism signifie la forme, ce qui signifie que le concept de polymorphisme aide une entité à se comporter sous plusieurs formes. Par exemple, si nous avons une méthode Sum qui peut se comporter différemment, comme une qui peut obtenir la somme des variables a et b, et une autre qui peut également obtenir la somme mais pour différents paramètres comme a, b, et c.

Le polymorphisme signifie simplement une interface et de nombreuses méthodes.

Nous pouvons résumer ce que nous avons mentionné en disant que la POO est un modèle de programmation informatique qui se concentre sur l'organisation de la conception du logiciel par le biais d'objets qui peuvent avoir un comportement et des caractéristiques uniques. C'est une méthode utile pour les logiciels importants et complexes, en particulier si ce logiciel est mis à jour et manipulé fréquemment.

Attributs et caractéristiques de la POO

• Les logiciels qui appliquent l'approche POO comprennent des classes et des fonctions.
• Le haut niveau de sécurité, car les données sont cachées en appliquant les principes d'encapsulation et d'abstraction.
• Elle permet de travailler facilement sur des projets complexes, car le code peut être divisé en petits blocs de code, ce qui peut réduire la complexité du projet.
• Les processus de mise à jour et de développement sont plus faciles.
• Réutilisation du code par l'application du principe d'héritage.
• Possibilité de créer plusieurs instances de la même classe sans conflit.

Il existe de nombreux langages de programmation qui permettent d'appliquer l'approche POO. Les plus populaires sont par exemple C++, C#, Python, Java, JavaScript, PHP et d'autres. Le langage MQL5 est l'un des langages auxquels nous pouvons appliquer l'approche POO. C'est ce que nous allons apprendre dans la rubrique suivante.

La POO dans MQL5

Dans cette rubrique, nous allons découvrir la POO dans MQL5 et comment nous pouvons l'utiliser. Comme nous l'avons mentionné dans les bases de la POO, nous créons une classe qui est comme le plan d'un objet, et la classe elle-même est une collection ou contient des variables et des méthodes qui sont les mêmes qu'une fonction, mais elle est appelée une méthode dans la classe pour effectuer un ensemble spécifique de tâches. Il convient également de mentionner ici que les variables et les méthodes ou fonctions à l'intérieur de la classe sont appelées membres de la classe. Ce qu'il faut dire ici, c'est que c'est un effort positif et apprécié que l'application du concept POO soit disponible dans MQL5, car il permettra d'économiser beaucoup d'efforts et de travail, comme nous l'avons mentionné, en plus de la qualité et de la sécurité.

Si nous devons appliquer le concept de la POO à MQL5, nous devons comprendre comment nous pouvons utiliser les éléments suivants dans MQL5 :

• Classes
• Modificateur d'accès
• Constructeurs et destructeurs
• Classes dérivées (enfants)
• Fonctions virtuelles
• Objets

Classes

Dans MQL5, si nous avons besoin de créer une classe pour être le modèle d'un objet, nous devons déclarer cette classe dans la portée globale, de la même manière que les fonctions. Nous pouvons créer cette classe en utilisant le mot-clé class suivi du nom unique désiré, puis entre ou à l'intérieur des deux accolades, nous pouvons placer nos variables et méthodes membres de la classe. Après la deuxième accolade, nous plaçons un point-virgule pour terminer la déclaration de la classe. D'ailleurs, nous pouvons utiliser cette déclaration de classe dans le programme ou dans le fichier d'inclusion.

Voici un exemple de déclaration de classe :

class Cobject
{
   int var1;       // variable1
   double var2;    // variable1
   void method1(); // Method or function1
};

Comme nous pouvons le voir dans l'exemple précédent, nous avons 3 membres dans la classe, à savoir 2 variables et 1 méthode ou fonction.

Modificateurs d'accès

Grâce à ces modificateurs d'accès, nous pouvons déterminer quelles variables et fonctions nous pouvons utiliser en dehors de la classe. Nous disposons de 3 mots-clés d'accès : public, private et protected.

• Public : représente les membres qui peuvent être utilisés en dehors de la classe.
• Privé : représente les membres qui ne peuvent pas être utilisés en dehors de la classe, qui ne peuvent être utilisés qu'à l'intérieur de la classe par des fonctions. La classe enfant de cette classe n'héritera pas de ces membres privés.
• Protected : représente les membres qui seront hérités par les classes enfants mais qui sont privés par nature.

Voici un exemple :

class Cobject
{
   private:
   int var1;       // variable1
   protected:
   double var2;    // variable1
   public:
   void method1(); // Method or function1
};

Comme nous pouvons le voir dans l'exemple précédent, nous avons 3 membres dans la classe avec 2 variables : l'une est privée, l'autre est protégée et le troisième membre est public.

Constructeurs et Destructeurs

Si nous devons initialiser des variables dans la classe, nous utilisons le constructeur. Il sera créé par défaut par le compilateur si nous ne l'avons pas fait, mais ce constructeur par défaut ne sera pas visible. Il doit également être public, conformément à l'accessibilité. D'autre part, le destructeur est une fonction automatiquement appelée lorsqu'un objet de la classe est détruit. Le nom du destructeur est identique au nom de la classe avec un tilde (~). Que le destructeur existe ou non, les chaînes de caractères, les tableaux dynamiques et tout objet nécessitent une dé-initialisation et seront donc dé-initialisés de toute façon.

Voici un exemple de constructeur :

class CPrices
  {
private:
   double               open;         // Open price
   double               high;         // High price
   double               low;          // Low price
   double               close;        // Close price
public:
   //--- Default constructor
                     CPrices(void);
   //--- Parametric constructor
                     CPrices(double o,double h,double l, double c);
  };

Classes Dérivées (Enfants)

Comme nous l'avons appris précédemment, le concept d'héritage est l'une des caractéristiques les plus précieuses et les plus utiles de la POO, car nous pouvons créer une classe enfant à partir d'une classe parente. Et cette classe enfant hérite de tous les membres de la classe parentale, à l'exception des membres privés. Nous pouvons ensuite ajouter de nouvelles variables et fonctions dans cette classe enfant.

Si nous avons une classe mère pour les prix, nous pouvons créer une classe enfant pour les prix quotidiens, comme dans l'exemple suivant :

class CDailyPrices : public CPrices
{
public:
   double               open;          // Open price
   double               high;          // High price
   double               low;           // Low price
   double               close;         // Close price
};

Comme nous pouvons le voir, le nom de la classe mère est CPrices et CDailyPrices est la classe enfant ou dérivée. Nous constatons maintenant que tous les membres publics et protégés de CPrices font partie de la classe CDailyPrices et qu'ils sont toujours publics.

Fonctions Virtuelles

Si nous voulons mettre à jour le fonctionnement d'une méthode ou d'une fonction dans une classe enfant, nous pouvons utiliser une fonction virtuelle dans la classe parente, puis en définissant la fonction dans la classe enfant. Par exemple, si nous avons 2 versions différentes d'une fonction basée sur une classe. Pour la classe mère, nous définissons la fonction à l'aide du mot-clé virtual :

class CVar
  {
public:
   virtual 
void varCal();
  };

Ensuite, nous mettrons à jour la même fonction dans la classe enfant :

class CVar1 : public CVar
{
public:
 int varCal(int x, int y);
}; 

Objets

Les objets ont un identifiant unique, de la même manière que nous le faisons lorsque nous créons une variable. Nous utiliserons le nom de la classe comme type avant l'identifiant de l'objet. Nous pouvons créer autant d'objets appartenant à nos classes que nécessaire pour le projet. Nous n’avons besoin que d'utiliser un identifiant unique pour chacun d'entre eux. Après avoir déclaré l'objet, nous pouvons accéder à n'importe quel membre public en utilisant le point (.).

Voyons un exemple pour le comprendre clairement en créant une classe ayant une variable entière num_trades représentant le nombre de transactions :

class CSystrades
{
public:
int num_trades;
};

Nous devons ensuite créer un objet appartenant à cette classe, appelé system1, en procédant comme suit :

CSystrades system1;

On peut alors initialiser cet objet avec la valeur 3 :

system1.num_trades=3;

Nous avons maintenant compris comment nous pouvons appliquer l'approche de la POO dans MQL5 en apprenant quelques-unes des idées les plus importantes à ce sujet dans cette rubrique.

Applications POO

Dans cette partie intéressante, nous présenterons quelques applications simples de l'approche POO dans nos logiciels afin de bien comprendre comment nous pouvons l'utiliser et dans quelle mesure elle peut être utile.

Application priceClass

Dans cette application simple, nous avons besoin de vérifier les prix de plusieurs périodes. Dans cet exemple, nous présenterons 3 périodes (quotidien, hebdomadaire et mensuel). Ici, nous avons besoin de voir tous les prix (ouverture, haut, bas, clôture) et nous avons besoin de les voir à un seul endroit, disons dans l'onglet Experts. Ensuite, nous pouvons développer davantage cet exemple simple pour mettre en œuvre des logiciels plus avancés.

Tout d'abord, nous devons déclarer la classe à l'aide de l'étape suivante :

• Nous devons déclarer une classe pour les prix dans la portée globale et inclure tous les membres communs comme publics en utilisant le mot-clé class.
• Utiliser le mot-clé public.
• Créer 5 variables (timeframe, open, high, low et close).
• Créer une fonction void pour afficher toutes les données de prix.

class CPrices
  {
public:
   string            timeFrame;
   double            open;
   double            high;
   double            low;
   double            close;
   void              pricesPrint()
     {
      Print(timeFrame," Prices = Open: ",open," - ","High: ",high,"-","Low: ",low,"-","Close: ",close);
     }
  };

Créez des objets à partir de la classe pour les prix quotidiens, hebdomadaires et mensuels :

CPrices CDailyPrices;
CPrices CWeeklyPrices;
CPrices CMonthlyPrices;

Dans la fonction OnInit, nous définirons les éléments suivants pour les 3 périodes :

• Une chaîne de caractères pour la période
• Le prix d'ouverture à l'aide de la fonction iOpen
• Le prix le plus haut à l'aide de la fonction iHigh
• Le prix le plus bas à l'aide de la fonction iLow
• Le prix de clôture à l'aide de la fonction iClose
• Appel de la fonction ou de la méthode d'affichage

int OnInit()
  {
//--- Daily time frame
   CDailyPrices.timeFrame="Daily";
   CDailyPrices.open=(iOpen(Symbol(),PERIOD_D1,1));
   CDailyPrices.high=(iHigh(Symbol(),PERIOD_D1,1));
   CDailyPrices.low=(iLow(Symbol(),PERIOD_D1,1));
   CDailyPrices.close=(iClose(Symbol(),PERIOD_D1,1));
   CDailyPrices.pricesPrint();

//--- Weekly time frame
   CWeeklyPrices.timeFrame="Weekly";
   CWeeklyPrices.open=(iOpen(Symbol(),PERIOD_W1,1));
   CWeeklyPrices.high=(iHigh(Symbol(),PERIOD_W1,1));
   CWeeklyPrices.low=(iLow(Symbol(),PERIOD_W1,1));
   CWeeklyPrices.close=(iClose(Symbol(),PERIOD_W1,1));
   CWeeklyPrices.pricesPrint();

//--- Monthly time frame
   CMonthlyPrices.timeFrame="Monthly";
   CMonthlyPrices.open=(iOpen(Symbol(),PERIOD_MN1,1));
   CMonthlyPrices.high=(iHigh(Symbol(),PERIOD_MN1,1));
   CMonthlyPrices.low=(iLow(Symbol(),PERIOD_MN1,1));
   CMonthlyPrices.close=(iClose(Symbol(),PERIOD_MN1,1));
   CMonthlyPrices.pricesPrint();
   return(INIT_SUCCEEDED);
  }

Les prix seront alors affichés après l'exécution de cet expert dans l'onglet Experts de la boîte à outils de la manière suivante :

Comme nous pouvons le voir dans l'image précédente, nous avons 3 lignes imprimées :

• La première ligne affiche les prix quotidiens de l'ouverture, du plus haut, du plus bas et de la clôture.
• La seconde imprime les mêmes prix mais correspond aux données hebdomadaires.
• La troisième ligne imprime la même chose mais concerne les données mensuelles.

Application indicatorClass

Nous devons créer un logiciel capable d'afficher les valeurs de 4 types de moyennes mobiles (moyennes simples, exponentielles, lissées et pondérées linéaires) en utilisant l'approche de la POO :

Déclarez la classe de l'indicateur CiMA en utilisant le mot-clé class, et créez les membres publics de cette classe. Il s'agit de 4 variables communes MAType pour définir le type de la moyenne mobile, MAArray pour définir le tableau de la moyenne mobile, MAHandle pour définir le handle de chaque type, MAValue pour définir la valeur de chaque moyenne mobile. Créez une méthode ou une fonction void valuePrint et le corps de la fonction pour afficher la valeur de chaque type de moyenne mobile.

class CiMA
  {
public:
   string            MAType;
   double            MAArray[];
   int               MAHandle;
   double            MAValue;
   void              valuePrint()
     {
      Print(MAType," Current Value: ",MAValue);
     };
  };

Créez les objets suivants pour chaque moyenne mobile de la classe :

• Le nom de la moyenne
• Le handle de la moyenne
• Le tableau de la moyenne

//--- SMA
CiMA CSma;
CiMA CSmaHandle;
CiMA CSmaArray;

//--- EMA
CiMA CEma;
CiMA CEmaHandle;
CiMA CEmaArray;

//--- SMMA
CiMA CSmma;
CiMA CSmmaHandle;
CiMA CSmmaArray;

//--- LWMA
CiMA CLwma;
CiMA CLwmaHandle;
CiMA CLwmaArray;

Dans la fonction OnInit, nous effectuerons les étapes suivantes pour chaque type de moyenne mobile :

• Définir le nom de la moyenne
• Définir la poignée de la moyenne
• Attribution de l'indicateur AS_SERIES au tableau en utilisant la fonction ArraySetAsSeries
• Récupérer les données du buffer de l'indicateur de moyenne en utilisant la fonction CopyBuffer
• Définir la valeur de la moyenne et la normaliser à l'aide de la fonction NormalizeDouble
• Appel de la méthode ou de la fonction d’affichage créée

int OnInit()
  {
   //--- SMA
   CSma.MAType="Simple MA";
   CSmaHandle.MAHandle=iMA(_Symbol,PERIOD_CURRENT,10,0,MODE_SMA,PRICE_CLOSE);
   ArraySetAsSeries(CSmaArray.MAArray,true);
   CopyBuffer(CSmaHandle.MAHandle,0,0,3,CSmaArray.MAArray);
   CSma.MAValue=NormalizeDouble(CSmaArray.MAArray[1],_Digits);
   CSma.valuePrint();

   //--- EMA
   CEma.MAType="Exponential MA";
   CEmaHandle.MAHandle=iMA(_Symbol,PERIOD_CURRENT,10,0,MODE_EMA,PRICE_CLOSE);
   ArraySetAsSeries(CEmaArray.MAArray,true);
   CopyBuffer(CEmaHandle.MAHandle,0,0,3,CEmaArray.MAArray);
   CEma.MAValue=NormalizeDouble(CEmaArray.MAArray[1],_Digits);
   CEma.valuePrint();

   //--- SMMA
   CSmma.MAType="Smoothed MA";
   CSmmaHandle.MAHandle=iMA(_Symbol,PERIOD_CURRENT,10,0,MODE_SMMA,PRICE_CLOSE);
   ArraySetAsSeries(CSmmaArray.MAArray,true);
   CopyBuffer(CSmmaHandle.MAHandle,0,0,3,CSmmaArray.MAArray);
   CSmma.MAValue=NormalizeDouble(CSmmaArray.MAArray[1],_Digits);
   CSmma.valuePrint();

   //--- LWMA
   CLwma.MAType="Linear-weighted MA";
   CLwmaHandle.MAHandle=iMA(_Symbol,PERIOD_CURRENT,10,0,MODE_LWMA,PRICE_CLOSE);
   ArraySetAsSeries(CLwmaArray.MAArray,true);
   CopyBuffer(CLwmaHandle.MAHandle,0,0,3,CLwmaArray.MAArray);
   CLwma.MAValue=NormalizeDouble(CLwmaArray.MAArray[1],_Digits);
   CLwma.valuePrint();
   return(INIT_SUCCEEDED);
  }

Après avoir compilé et exécuté ce code, nous pouvons trouver 4 lignes pour chaque type de moyenne mobile, chaque ligne imprimant la valeur de la moyenne comme suit :

Comme je l'ai mentionné précédemment, nous pouvons développer ces applications pour mettre en œuvre des tâches plus compliquées et plus avancées. Mais ici l'objectif est d'apprendre et de comprendre les bases de la Programmation Orientée Objet (POO) et comment nous pouvons appliquer cette approche dans MQL5 grâce aux nombreuses fonctionnalités que nous pouvons obtenir.

Conclusion

Dans cet article, nous avons appris les bases d'un sujet et d'une approche très importants dans la programmation en général. Nous avons appris à quel point cette approche est très utile lors de la conception de nos logiciels en apprenant comment elle peut nous aider à créer des logiciels sûrs et hautement sécurisés, à réduire la complexité de la création du logiciel en divisant le code en petits blocs de code, ce qui facilite le processus de codage, à créer de nombreuses instances à partir de la même classe sans aucun conflit, même si elles ont un comportement différent. Tout cela donne plus de flexibilité et de sécurité lors de la mise à jour de nos logiciels.

Nous avons également appris comment appliquer cette approche importante dans MQL5 pour obtenir toutes ces fonctionnalités incroyables. Puis nous avons appris quelques applications simples qui peuvent être créées en appliquant l'approche de la POO dans MQL5 pour être utilisées dans MetaTrader 5.

J'espère que cet article vous sera utile et qu'il vous aidera à apprendre un sujet très important et crucial dans la programmation MQL5, car il peut vous donner plus d'informations sur le nombre d'idées qui peuvent être faciles à coder après l'application de cette approche POO.

Si vous avez aimé cet article et que vous voulez en savoir plus sur la façon dont vous pouvez créer des systèmes de trading dans MQL5 à utiliser dans MetaTrader 5 sur la base de l'indicateur technique le plus populaire et comment vous pouvez créer un indicateur technique personnalisé et l'utiliser dans votre Expert Advisor, vous pouvez lire mes autres articles sur ces sujets à travers la publication sur mon profil. J'espère que vous les trouverez utiles aussi.