MQL5 · Avancé
Héritage et polymorphisme en MQL5 : virtual, override, final et classes abstraites
Dériver une classe, redéfinir une méthode virtuelle, verrouiller une implémentation avec final et imposer un contrat avec une classe abstraite : construisez une famille de signaux interchangeables pilotée par un seul moteur d’EA.
L’héritage permet de créer une classe dérivée qui reprend les membres d’une classe de base et y ajoute ou modifie des comportements ; le polymorphisme permet ensuite de manipuler des objets de classes différentes à travers un pointeur sur leur classe de base commune, la bonne méthode étant choisie à l’exécution grâce au mot-clé virtual. En pratique, vous écrivez un moteur d’EA qui appelle signal.Direction() sans savoir s’il s’agit d’un croisement de moyennes, d’un RSI ou d’une cassure : ajouter une stratégie revient à ajouter une classe, sans toucher au moteur.
Cette page prolonge Programmation orientée objet : classes dans la rubrique MQL5 avancé. Nous y verrons la syntaxe de dérivation, les fonctions virtuelles, les modificateurs override et final, les classes abstraites, puis un exemple complet.
Dériver une classe
La syntaxe reprend celle du C++ : class CSignalMA : public CSignal. Le mot-clé public indique que les membres publics de la base restent publics dans la classe dérivée. La documentation MQL5 illustre l’héritage avec une classe de base « forme » et sept classes dérivées pour les pièces d’un Tetris : le comportement commun est écrit une seule fois dans la base, et chaque dérivée ne contient que ce qui lui est propre.
Pour le trading, la base contient typiquement le symbole, la période et un nom lisible ; les dérivées contiennent leurs handles d’indicateurs et leur logique. Les membres que les dérivées doivent lire sont déclarés protected : invisibles de l’extérieur, accessibles aux descendantes. Le constructeur d’une classe dérivée appelle celui de la base dans sa liste d’initialisation, avant d’initialiser ses propres membres.
Rappel utile : une classe ne peut hériter que d’une classe, une structure que d’une structure.
Fonctions virtuelles : le choix à l’exécution
Sans virtual, l’appel d’une méthode via un pointeur de type CSignal* exécute toujours la version de CSignal, même si l’objet réel est un CSignalMA. Avec virtual, la documentation précise que la méthode appelée dépend du type de l’objet, et non du type du pointeur. Si la classe dérivée ne redéfinit pas la méthode, la version de la base est utilisée.
Deux règles complètent ce mécanisme. Les structures ne peuvent pas avoir de fonctions virtuelles. Et les destructeurs sont toujours virtuels, même sans le mot-clé : supprimer un objet dérivé via un pointeur de base appelle donc bien le destructeur de la dérivée, ce qui est essentiel pour libérer ses handles.
override et final : se protéger des erreurs silencieuses
Le piège classique de l’héritage est la redéfinition ratée : vous écrivez int Direction(int shift) dans la base et int Direction(long shift) dans la dérivée. Les signatures diffèrent, il ne s’agit donc pas d’une redéfinition mais d’une nouvelle méthode, et le moteur continue d’appeler la version de base sans aucun message. Le modificateur override règle ce problème : il déclare que la méthode doit redéfinir une méthode parente. Si ce n’est pas le cas, le compilateur produit l’erreur « method is declared with ‘override’ specifier but does not override any base class method ». Ajoutez-le systématiquement.
Le modificateur final, placé sur une méthode virtuelle, interdit sa redéfinition dans les classes enfants ; toute tentative provoque une erreur de compilation. Utilisez-le pour verrouiller une logique qui ne doit pas varier, par exemple une méthode de contrôle de risque commune à toutes les stratégies.
Classes abstraites et fonctions virtuelles pures
Une fonction virtuelle pure se déclare avec =0 (ou =NULL) : virtual int Direction(void)=0;. Une classe qui contient au moins une fonction virtuelle pure est abstraite : on ne peut pas en créer d’objet, elle ne sert que de base. Une classe dérivée qui ne redéfinit pas toutes les fonctions virtuelles pures reste elle-même abstraite.
C’est exactement ce que l’on veut pour un « contrat » de signal : la base CSignal impose que toute stratégie sache dire sa direction, sans fournir d’implémentation par défaut qui pourrait masquer un oubli. Attention à une subtilité documentée : appeler une fonction virtuelle pure depuis le constructeur de la classe abstraite, directement ou indirectement, donne un résultat indéfini. N’appelez donc pas Direction() ou Init() depuis un constructeur de base.
Exemple complet : des signaux interchangeables
L’EA ci-dessous déclare une base abstraite CSignal, deux dérivées (croisement de moyennes mobiles et RSI), puis les stocke dans un tableau de pointeurs de base. Le moteur combine les votes sans connaître les classes concrètes.
//+------------------------------------------------------------------+
//| SignalsPoly.mq5 : polymorphisme appliqué aux signaux d'entrée |
//+------------------------------------------------------------------+
//--- classe de base abstraite : le contrat de tout signal
class CSignal
{
protected:
string m_symbol;
ENUM_TIMEFRAMES m_tf;
string m_name;
public:
CSignal(const string symbol,const ENUM_TIMEFRAMES tf,const string name)
: m_symbol(symbol),m_tf(tf),m_name(name) {}
~CSignal(void) {}
string Name(void) const { return(m_name); }
virtual bool Init(void)=0; // créer les handles
virtual int Direction(void)=0; // +1 achat, -1 vente, 0 neutre
};
//--- signal 1 : croisement de deux moyennes mobiles (bougie 1 contre bougie 2)
class CSignalMA : public CSignal
{
private:
int m_fast,m_slow;
int m_h_fast,m_h_slow;
public:
CSignalMA(const string s,const ENUM_TIMEFRAMES tf,const int fast,const int slow)
: CSignal(s,tf,"MA"),m_fast(fast),m_slow(slow),
m_h_fast(INVALID_HANDLE),m_h_slow(INVALID_HANDLE) {}
~CSignalMA(void)
{
if(m_h_fast!=INVALID_HANDLE) IndicatorRelease(m_h_fast);
if(m_h_slow!=INVALID_HANDLE) IndicatorRelease(m_h_slow);
}
virtual bool Init(void) override
{
m_h_fast=iMA(m_symbol,m_tf,m_fast,0,MODE_EMA,PRICE_CLOSE);
m_h_slow=iMA(m_symbol,m_tf,m_slow,0,MODE_EMA,PRICE_CLOSE);
return(m_h_fast!=INVALID_HANDLE && m_h_slow!=INVALID_HANDLE);
}
virtual int Direction(void) override
{
double f[],s[];
if(CopyBuffer(m_h_fast,0,1,2,f)!=2) return(0);
if(CopyBuffer(m_h_slow,0,1,2,s)!=2) return(0);
// f[0]=bougie 2 (plus ancienne), f[1]=bougie 1
if(f[0]<=s[0] && f[1]>s[1]) return(+1);
if(f[0]>=s[0] && f[1]<s[1]) return(-1);
return(0);
}
};
//--- signal 2 : RSI sorti d'une zone extrême
class CSignalRSI : public CSignal
{
private:
int m_period,m_handle;
double m_low,m_high;
public:
CSignalRSI(const string s,const ENUM_TIMEFRAMES tf,const int period,
const double low,const double high)
: CSignal(s,tf,"RSI"),m_period(period),m_handle(INVALID_HANDLE),
m_low(low),m_high(high) {}
~CSignalRSI(void) { if(m_handle!=INVALID_HANDLE) IndicatorRelease(m_handle); }
virtual bool Init(void) override
{
m_handle=iRSI(m_symbol,m_tf,m_period,PRICE_CLOSE);
return(m_handle!=INVALID_HANDLE);
}
virtual int Direction(void) override
{
double r[];
if(CopyBuffer(m_handle,0,1,2,r)!=2) return(0);
if(r[0]<m_low && r[1]>=m_low) return(+1); // sortie de survente
if(r[0]>m_high && r[1]<=m_high) return(-1); // sortie de surachat
return(0);
}
};
//--- le moteur ne connaît que CSignal*
CSignal *g_signals[];
int OnInit()
{
ArrayResize(g_signals,2);
g_signals[0]=new CSignalMA(_Symbol,PERIOD_CURRENT,20,50);
g_signals[1]=new CSignalRSI(_Symbol,PERIOD_CURRENT,14,30.0,70.0);
for(int i=0;i<ArraySize(g_signals);i++)
if(!g_signals[i].Init())
{
Print("Échec d'initialisation du signal ",g_signals[i].Name());
return(INIT_FAILED);
}
return(INIT_SUCCEEDED);
}
void OnDeinit(const int reason)
{
for(int i=0;i<ArraySize(g_signals);i++)
if(CheckPointer(g_signals[i])==POINTER_DYNAMIC)
delete g_signals[i]; // destructeur de la classe dérivée appelé
ArrayFree(g_signals);
}
void OnTick()
{
int votes=0;
for(int i=0;i<ArraySize(g_signals);i++)
votes+=g_signals[i].Direction(); // appel polymorphe
if(votes!=0)
PrintFormat("%s : somme des votes = %d",TimeToString(TimeCurrent()),votes);
}
Remarquez que OnTick ne contient aucune référence à CSignalMA ou CSignalRSI. Pour tester une troisième stratégie, il suffit d’écrire CSignalBreakout, de redéfinir Init et Direction, et d’ajouter une ligne dans OnInit. Par ailleurs, ce moteur appelle les signaux à chaque tick, ce qui est inutile pour des signaux calculés sur bougie clôturée : combinez-le avec la technique décrite dans Détecter une nouvelle bougie.
Concevoir une bonne hiérarchie pour un EA
Quelques principes évitent de transformer l’héritage en labyrinthe.
- Héritez pour un comportement, pas pour réutiliser du code. Une classe dérivée doit pouvoir remplacer sa base partout où celle-ci est utilisée. Si vous héritez seulement pour récupérer deux fonctions utilitaires, préférez la composition : un membre de type
CRiskManagerplutôt qu’un héritage deCRiskManager. - Gardez les hiérarchies peu profondes. Deux ou trois niveaux suffisent dans un EA. Au-delà, retrouver quelle version d’une méthode s’exécute devient pénible au débogage.
- Une base abstraite par rôle : signal d’entrée, filtre, gestion de sortie, dimensionnement. Le moteur assemble des objets de chaque rôle ; c’est l’idée que reprennent les modules de stratégie de la bibliothèque standard, présentés dans La bibliothèque standard.
- Pas de logique dans les constructeurs de base qui dépende de méthodes virtuelles : utilisez une méthode
Init()explicite, appelée après la construction.
Pièges fréquents
- Oublier
virtualdans la base : la dérivée compile, mais l’appel via un pointeur de base exécute la version de base.overridesur la dérivée révèle immédiatement l’erreur. - Signature légèrement différente (
constmanquant, typeintau lieu delong) : sansoverride, c’est une surcharge et non une redéfinition. - Objets dérivés stockés par valeur : le polymorphisme exige des pointeurs. Un tableau de
CSignal(et non deCSignal*) est d’ailleurs impossible si la classe est abstraite. - Fuites mémoire : chaque
newdu tableau doit avoir sondeletedansOnDeinit, avec contrôle parCheckPointer.
Questions fréquentes
MQL5 accepte-t-il l’héritage multiple ?
Une classe MQL5 ne dérive que d’une seule classe de base. Pour combiner plusieurs comportements, utilisez la composition : la classe contient des membres d’autres types et leur délègue le travail.
Faut-il écrire virtual dans la classe dérivée en plus d’override ?
Ce n’est pas obligatoire pour obtenir la redéfinition dès lors que la méthode est virtuelle dans la base, mais l’écrire améliore la lisibilité. Le mot-clé important est override, qui fait vérifier la redéfinition par le compilateur.
Pourquoi mon destructeur de classe dérivée est-il bien appelé via un pointeur de base ?
Parce qu’en MQL5 les destructeurs sont toujours virtuels, qu’ils soient déclarés virtual ou non. Supprimer un CSignal* qui pointe vers un CSignalMA exécute donc le destructeur de CSignalMA, puis celui de CSignal.
Quand utiliser final ?
Sur une méthode dont le comportement ne doit jamais être modifié par une classe enfant, par exemple une vérification de risque commune à toutes vos stratégies. Toute tentative de redéfinition sera refusée à la compilation.
- Programmation orientée objet : classes
- 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
