MQL5 · Avancé
Classes en MQL5 : la programmation orientée objet appliquée aux Expert Advisors
Membres privés et publics, constructeurs, destructeurs, objets dynamiques et pointeurs : comment écrire vos premières classes MQL5 pour transformer un EA monolithique en composants clairs, testables et réutilisables.
Une classe MQL5 regroupe dans un même type des données (les membres) et les fonctions qui les manipulent (les méthodes). Vous la déclarez avec le mot-clé class, vous protégez ses données avec private ou protected, vous exposez une interface avec public, et vous créez ensuite des objets, soit automatiquement comme une variable ordinaire, soit dynamiquement avec new. Pour un trader-développeur, l’intérêt est immédiat : au lieu d’un OnTick de trois cents lignes et de variables globales modifiées de partout, chaque responsabilité (calcul du risque, gestion des sorties, journalisation) vit dans un objet autonome que vous pouvez réutiliser d’un robot à l’autre.
Cette page fait partie de la rubrique MQL5 avancé. Elle suppose que vous connaissez les fonctions et les structures ; si ce n’est pas le cas, relisez d’abord Structures (struct) et MqlRates, MqlTick.
Pourquoi passer aux classes dans un Expert Advisor
La programmation orientée objet, telle que la décrit la documentation MQL5, repose sur l’encapsulation, l’extensibilité des types, l’héritage, le polymorphisme et la surcharge. Dans un EA, l’encapsulation est la plus rentable dès le premier jour. Prenons un calcul de taille de lot : il dépend du solde, du pourcentage de risque, de la distance du stop, de la valeur du tick et des contraintes de volume du symbole. Écrit en fonctions libres, il finit par lire des variables globales dispersées. Écrit en classe, il conserve ses paramètres en interne, les valide une fois à l’initialisation et n’expose qu’une méthode : « donne-moi le volume pour un stop de N points ».
Les bénéfices pratiques sont concrets :
- Lisibilité :
OnTickdevient une suite d’appels explicites (signal.Check(),risk.Volume(),exits.Manage()). - Réutilisation : la même classe se copie dans un fichier
.mqhet s’inclut dans tous vos projets avec#include. - Sécurité : les données privées ne peuvent pas être modifiées par erreur depuis l’extérieur ; le compilateur refuse l’accès.
- Instances multiples : un EA multi-symboles crée simplement un objet par symbole, chacun avec son propre état.
Déclarer une classe : membres et spécificateurs d’accès
Une classe se déclare comme une structure, avec trois niveaux d’accès :
public: membres accessibles depuis n’importe quel endroit du programme ;protected: accessibles depuis les méthodes de la classe et de ses descendantes ;private: accessibles uniquement depuis les méthodes de la classe elle-même.
Point important : dans une class, tous les membres sont privés par défaut ; dans une struct, ils sont publics par défaut. Autre différence documentée : une classe ne peut hériter que d’une classe et une structure que d’une structure, et seules les classes peuvent posséder des fonctions virtuelles. Si votre type ne fait que transporter des valeurs (un prix, un volume, une heure), une structure suffit ; dès qu’il a un comportement et un état à protéger, choisissez une classe.
Les méthodes peuvent être écrites dans la déclaration ou en dehors, grâce à l’opérateur de résolution de portée :: précédé du nom de la classe. Pour des classes de plus de quelques méthodes, déclarez-les dans le corps de la classe et définissez-les ensuite : la déclaration sert alors de sommaire lisible.
Constructeurs, liste d’initialisation et destructeur
Le constructeur est une fonction spéciale, portant le nom de la classe, appelée automatiquement à la création de l’objet. Sans paramètre, c’est le constructeur par défaut ; si vous n’en déclarez aucun, le compilateur en génère un. Un constructeur qui exige des arguments est dit paramétrique.
La liste d’initialisation, placée après les paramètres du constructeur et un deux-points, initialise les membres avant l’exécution du corps. Attention : la documentation précise que les membres sont initialisés dans l’ordre de leur déclaration dans la classe, pas dans l’ordre de la liste. Si un membre dépend d’un autre, déclarez-les dans le bon ordre.
Le destructeur porte le nom de la classe précédé d’un tilde (~CRiskManager). Il est appelé à la destruction de l’objet : fin de portée pour un objet automatique, delete pour un objet dynamique. C’est l’endroit pour libérer un handle d’indicateur avec IndicatorRelease ou fermer un fichier. En MQL5, les destructeurs sont toujours virtuels, qu’ils soient déclarés virtual ou non.
Objets automatiques, objets dynamiques et pointeurs
Un objet déclaré comme une variable (CRiskManager risk;) est automatique : il est créé et détruit par l’environnement. Un objet créé avec new est dynamique : il existe jusqu’à ce que vous l’effaciez avec delete. En MQL5, new ne renvoie pas une adresse mémoire au sens du C++ mais un descripteur ; on parle néanmoins de pointeur, et on accède aux membres avec le point (p.Methode()).
Un pointeur est invalide s’il vaut NULL ou si l’objet a déjà été supprimé. La fonction CheckPointer renvoie une valeur de l’énumération ENUM_POINTER_TYPE :
| Constante | Signification |
|---|---|
POINTER_INVALID | pointeur invalide |
POINTER_DYNAMIC | objet créé avec new |
POINTER_AUTOMATIC | objet créé automatiquement par l’environnement |
Utiliser un pointeur invalide provoque un arrêt critique du programme. Avant chaque delete, vérifiez donc que CheckPointer(p)==POINTER_DYNAMIC. Les objets passés en paramètre de fonction le sont par référence (CRiskManager &rm). Pour le diagnostic de ces arrêts, consultez la page Pointeur invalide.
Exemple complet : un gestionnaire de risque encapsulé
L’exemple suivant définit une classe CRiskManager qui calcule le volume à partir d’un pourcentage de risque et d’une distance de stop en points, puis l’utilise dans un EA. Les propriétés du symbole sont lues avec SymbolInfoDouble, le solde avec AccountInfoDouble.
//+------------------------------------------------------------------+
//| RiskManager.mq5 : une classe de calcul de volume |
//+------------------------------------------------------------------+
class CRiskManager
{
private:
string m_symbol; // symbole géré
double m_risk_pct; // risque par trade en % du solde
double m_vol_min; // volume minimal du symbole
double m_vol_max; // volume maximal
double m_vol_step; // pas de volume
double NormalizeVolume(double vol) const;
public:
CRiskManager(const string symbol,const double risk_pct);
~CRiskManager(void) { Print("CRiskManager détruit pour ",m_symbol); }
bool IsValid(void) const { return(m_vol_step>0.0 && m_risk_pct>0.0); }
double Volume(const double stop_points) const;
};
//--- constructeur : liste d'initialisation dans l'ordre de déclaration
CRiskManager::CRiskManager(const string symbol,const double risk_pct)
: m_symbol(symbol),
m_risk_pct(risk_pct),
m_vol_min(SymbolInfoDouble(symbol,SYMBOL_VOLUME_MIN)),
m_vol_max(SymbolInfoDouble(symbol,SYMBOL_VOLUME_MAX)),
m_vol_step(SymbolInfoDouble(symbol,SYMBOL_VOLUME_STEP))
{
}
//--- arrondit le volume au pas inférieur et le borne
double CRiskManager::NormalizeVolume(double vol) const
{
vol=MathFloor(vol/m_vol_step)*m_vol_step;
if(vol<m_vol_min) return(0.0); // trop petit : on ne trade pas
if(vol>m_vol_max) vol=m_vol_max;
return(NormalizeDouble(vol,8));
}
//--- volume pour une perte maximale = risk_pct % du solde
double CRiskManager::Volume(const double stop_points) const
{
if(!IsValid() || stop_points<=0.0) return(0.0);
double tick_value=SymbolInfoDouble(m_symbol,SYMBOL_TRADE_TICK_VALUE);
double tick_size =SymbolInfoDouble(m_symbol,SYMBOL_TRADE_TICK_SIZE);
double point =SymbolInfoDouble(m_symbol,SYMBOL_POINT);
if(tick_value<=0.0 || tick_size<=0.0) return(0.0);
double risk_money=AccountInfoDouble(ACCOUNT_BALANCE)*m_risk_pct/100.0;
double loss_per_lot=stop_points*point/tick_size*tick_value; // perte pour 1 lot
return(NormalizeVolume(risk_money/loss_per_lot));
}
//--- paramètres de l'EA
input double InpRiskPct =1.0; // risque par trade (%)
input int InpStopPts =300; // distance du stop (points)
CRiskManager *g_risk=NULL; // objet dynamique
int OnInit()
{
g_risk=new CRiskManager(_Symbol,InpRiskPct);
if(CheckPointer(g_risk)==POINTER_INVALID || !g_risk.IsValid())
return(INIT_FAILED);
PrintFormat("Volume pour %d points : %.2f",InpStopPts,g_risk.Volume(InpStopPts));
return(INIT_SUCCEEDED);
}
void OnDeinit(const int reason)
{
//--- on ne supprime que ce qui a été créé avec new
if(CheckPointer(g_risk)==POINTER_DYNAMIC)
delete g_risk;
g_risk=NULL;
}
void OnTick()
{
// ici : g_risk.Volume(...) au moment d'un signal d'entrée
}
Plusieurs détails méritent l’attention. Les méthodes qui ne modifient pas l’objet sont déclarées const, ce qui documente l’intention et empêche une modification accidentelle. NormalizeVolume est privée : c’est un détail d’implémentation, l’utilisateur de la classe n’a pas à la connaître. Enfin, le volume renvoyé vaut zéro quand le calcul donne moins que le minimum autorisé : il est plus prudent de ne pas trader que d’arrondir au minimum et de risquer davantage que prévu. Le détail de ce calcul est approfondi dans Calculer et normaliser la taille de lot.
Objet automatique ou dynamique : que choisir ?
Dans la plupart des EA, un objet automatique déclaré au niveau global suffit, et il vous épargne toute gestion de delete. Préférez-le par défaut. L’objet dynamique devient utile quand le nombre d’objets n’est connu qu’à l’exécution (un objet par symbole lu dans un paramètre texte), quand l’objet ne peut être construit qu’après une vérification dans OnInit, ou quand vous manipulez une hiérarchie de classes par l’intermédiaire d’un pointeur sur la classe de base, ce que montre la page Héritage et polymorphisme.
Pièges fréquents en trading
- Oublier le
delete: chaquenewsansdeletecorrespondant laisse un objet en mémoire ; le terminal signale ces objets non supprimés dans le journal à l’arrêt du programme. Associez systématiquement la création dansOnInità la suppression dansOnDeinit. - Double suppression : supprimer deux fois le même objet, ou utiliser un pointeur après
delete, provoque un arrêt critique. Remettez le pointeur àNULLaprès suppression. - Lire les propriétés du symbole trop tôt : un constructeur exécuté sur un objet global l’est avant
OnInit. Si le symbole n’est pas encore synchronisé, certaines valeurs peuvent être nulles. Prévoyez une méthode d’initialisation explicite ou une validation commeIsValid(). - Classe fourre-tout : une classe
CExpertqui fait tout reproduit le problème du code monolithique. Une classe, une responsabilité. - Copier un objet par erreur : passez les objets par référence dans vos fonctions, comme l’exige MQL5, et évitez d’en dupliquer l’état.
Questions fréquentes
Quelle est la différence entre une classe et une structure en MQL5 ?
Les membres d’une classe sont privés par défaut, ceux d’une structure publics. Une classe hérite uniquement d’une classe, une structure d’une structure, et seules les classes peuvent avoir des fonctions virtuelles. Utilisez une structure pour regrouper des données simples, une classe pour un composant avec comportement et état.
Dois-je toujours créer mes objets avec new ?
Non. Un objet automatique, déclaré comme une variable, est plus simple et sans risque de fuite mémoire. Réservez new aux cas où le nombre d’objets est dynamique, où la création dépend d’une condition, ou au polymorphisme via un pointeur de classe de base.
Comment savoir si un pointeur peut être utilisé ?
Appelez CheckPointer : la valeur POINTER_INVALID indique un pointeur nul ou un objet supprimé. Vous pouvez aussi comparer le pointeur à NULL. Avant un delete, vérifiez que la fonction renvoie POINTER_DYNAMIC.
Où ranger mes classes pour les réutiliser ?
Placez chaque classe dans un fichier .mqh sous le dossier MQL5\Include (par exemple dans un sous-dossier à votre nom) et incluez-la avec #include <MonDossier\RiskManager.mqh>. Une modification profite alors à tous vos projets à la recompilation.
- Héritage et polymorphisme
- La bibliothèque standard
- Matrices et vecteurs
- Modèles ONNX dans MQL5
- Le module Python MetaTrader5
- Lire et écrire des fichiers CSV
- Bases de données SQLite
- WebRequest et API externes
- Importer des DLL
- Le calendrier économique en MQL5
- Profiler et optimiser son code
- Versionner son code (MQL5 Algo Forge)
- Publier un produit sur le Market MQL5
