Nouveau : la formation trading algorithmique MQL5, MQL4 et ProRealTimeDécouvrir →

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.

Mis à jour le 23 octobre 2026Lecture : 9 minPar Alix, OptiBot Trading

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 CRiskManager plutôt qu’un héritage de CRiskManager.
  • 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 virtual dans la base : la dérivée compile, mais l’appel via un pointeur de base exécute la version de base. override sur la dérivée révèle immédiatement l’erreur.
  • Signature légèrement différente (const manquant, type int au lieu de long) : sans override, 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 de CSignal*) est d’ailleurs impossible si la classe est abstraite.
  • Fuites mémoire : chaque new du tableau doit avoir son delete dans OnDeinit, avec contrôle par CheckPointer.
Combiner plusieurs signaux ne garantit aucune performance : chaque combinaison est une hypothèse à valider en backtest puis en démo, avec des coûts réalistes, avant toute utilisation sur un compte réel.

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.

A

Alix · fondateur d’OptiBot Trading

Développeur MQL5 et ProBuilder, spécialiste du backtest et de l’optimisation de stratégies automatiques. Chaque contenu est vérifié sur la documentation officielle (MQL5.com, manuels ProRealTime) et testé avant publication. Notre méthode éditoriale.