Référence MQL5Constantes, Enumérations et StructuresConstantes NomméesMacros de Substitutions Prédéfinies

Substitutions de Macro Prédéfinies

Pour simplifier le déboguage et obtenir des informations sur les opérations d'un programme mql5, il existe des constantes spéciales de macro, dont les valeurs sont définies au moment de la compilation. La façon la plus facile d'utiliser ces constantes est d'afficher les valeurs avec la fonction Print(), comme montré dans l'exemple.

Constante	Description
__DATE__	Date de compilation du fichier sans l'heure (les heures, minutes et secondes sont égales à 0)
__DATETIME__	Date et heure de compilation du fichier
__LINE__	Numéro de ligne dans le code source où la macro est située
__FILE__	Nom du fichier compilé actuel
__PATH__	Chemin absolu vers le fichier en cours de compilation
__FUNCTION__	Nom de la fonction dans laquelle la macro est située
__FUNCSIG__	Signature de la fonction dans laquelle la macro est située. La sortie de la description complète des fonctions peut être utile pour identifier les fonctions surchargées
__MQLBUILD__,__MQL5BUILD__	Numéro de build du compilateur
__COUNTER__	Le compilateur remplace la valeur du compteur de 0 à N-1, où N est un nombre d'utilisations dans le code, pour chaque déclaration __COUNTER__ rencontrée. L'ordre __COUNTER__ est garanti lors de la recompilation du code source sans changement. La valeur __COUNTER__ est calculée de la manière suivante : la valeur initiale du compteur est 0, après chaque utilisation du compteur, sa valeur est augmentée de 1, tout d'abord, le compilateur étend toutes les macros et modèles en code source sur site, un code distinct est créé pour chaque spécialisation de fonction de modèle, un code séparé est créé pour chaque spécialisation de class /structure templatée, ensuite, le compilateur passe par le code source obtenu dans l'ordre défini et remplace chaque utilisation __COUNTER__ détectée par la valeur actuelle du compteur. L'exemple ci-dessous montre comment le compilateur gère le code source et remplace toutes les instances de __COUNTER__ qu'il rencontre par des valeurs séquentiellement croissantes.
__RANDOM__	Le compilateur insère une valeur aléatoire ulong pour chaque déclaration __RANDOM__.

Exemple :

#property copyright "Copyright © 2009, MetaQuotes Software Corp."
#property link      "https://www.metaquotes.net"
//+----------------------------------------------------------------------------------------------------+
//| Fonction d'initialisation de l'expert                                                              |
//+----------------------------------------------------------------------------------------------------+
void OnInit()
  {
//--- exemple de sortie de l'information de l'initialisation de l'Expert Advisor
   Print(" __FUNCTION__ = ",__FUNCTION__,"  __LINE__ = ",__LINE__);
//--- définit l'intervalle entre les évènements du timer
   EventSetTimer(5);
//---
  }
//+----------------------------------------------------------------------------------------------------+
//| Fonction de dé-initialisation de l'Expert                                                          |
//+----------------------------------------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//--- exemple de sortie de l'information de la dé-initialisation de l'Expert Advisor
   Print(" __FUNCTION__ = ",__FUNCTION__,"  __LINE__ = ",__LINE__);
//---
  }
//+----------------------------------------------------------------------------------------------------+
//| Fonction de tick de l'Expert                                                                       |
//+----------------------------------------------------------------------------------------------------+
void OnTick()
  {
//--- sortie de l'information à la réception d'un tick
   Print(" __FUNCTION__ = ",__FUNCTION__,"  __LINE__ = ",__LINE__);
   Print(" __FUNCTION__ = ",__FUNCTION__,"  __LINE__ = ",__LINE__);
   test1(__FUNCTION__);
   test2();
//---
  }
//+----------------------------------------------------------------------------------------------------+
//| test1                                                                                              |
//+----------------------------------------------------------------------------------------------------+
void test1(string par)
  {
//--- sortie d'information dans la fonction
   Print(" __FUNCTION__ = ",__FUNCTION__,"  __LINE__ = ",__LINE__," par=",par);
  }
//+----------------------------------------------------------------------------------------------------+
//| test2                                                                                              |
//+----------------------------------------------------------------------------------------------------+
void test2()
  {
//--- sortie d'information dans la fonction
   Print(" __FUNCTION__ = ",__FUNCTION__,"  __LINE__ = ",__LINE__);
  }
//+----------------------------------------------------------------------------------------------------+
//| Gestionnaire d'évènement OnTimer                                                                   |
//+----------------------------------------------------------------------------------------------------+
void OnTimer()
  {
//---
   Print(" __FUNCTION__ = ",__FUNCTION__,"  __LINE__ = ",__LINE__);
   test1(__FUNCTION__);
  }

L'exemple pour apprendre à travailler avec la macro __COUNTER__

// --- crée une macro pour un affichage rapide de l'expression et de sa valeur dans le journal
#define print(expr) Print(#expr,"=",expr)

// --- définir la macro personnalisée MACRO_COUNTER via la macro prédéfinie __COUNTER__
#define MACRO_COUNTER __COUNTER__

// --- définit la valeur d'entrée de la variable à l'aide de la macro __COUNTER__
input int InpVariable = __COUNTER__;

// --- définir la valeur de la variable globale à l'aide de la macro __COUNTER__ avant de définir les fonctions
int ExtVariable = __COUNTER__;

//+------------------------------------------------------------------+
//| la fonction renvoie la valeur __COUNTER__                        |
//+------------------------------------------------------------------+
int GlobalFunc(void)
  {
   return(__COUNTER__);
  }
//+------------------------------------------------------------------+
//| la fonction modèle renvoie la valeur __COUNTER__                 |
//+------------------------------------------------------------------+
template<typename T>
int GlobalTemplateFunc(void)
  {
   return(__COUNTER__);
  }
//+------------------------------------------------------------------+
//| la structure avec la méthode retournant __COUNTER__              |
//+------------------------------------------------------------------+
struct A
  {
   int               dummy;  // non utilisé

   int               Method(void)
     {
      return(__COUNTER__);
     }
  };
//+------------------------------------------------------------------+
//| la structure du modèle avec la méthode retournant __COUNTER__    |
//+------------------------------------------------------------------+
template<typename T>
struct B
  {
   int               dummy;  // non utilisé

   int               Method(void)
     {
      return(__COUNTER__);
     }
  };
//+------------------------------------------------------------------+
//| la structure avec la méthode template retournant __COUNTER__     |
//+------------------------------------------------------------------+
struct C
  {
   int               dummy;  // non utilisé

   template<typename T>
   int               Method(void)
     {
      return(__COUNTER__);
     }
  };
//+------------------------------------------------------------------+
//| la fonction # , qui renvoie la valeur __COUNTER__                |
//+------------------------------------------------------------------+
int GlobalFunc2(void)
  {
   return(__COUNTER__);
  }
//+------------------------------------------------------------------+
//| Fonction de démarrage du programme de script                     |
//+------------------------------------------------------------------+
void OnStart(void)
  {
// __COUNTER__ dans la macro et les variables
   print(MACRO_COUNTER);
   print(InpVariable);
   print(ExtVariable);

//--- __COUNTER__ dans les fonctions
   print(GlobalFunc());
   print(GlobalFunc());                // la valeur n'est pas changée
   print(GlobalTemplateFunc<int>());
   print(GlobalTemplateFunc<int>());   // la valeur n'est pas changée
   print(GlobalTemplateFunc<double>());// la valeur a été changée
   print(GlobalFunc2());
   print(GlobalFunc2());               // la valeur n'est pas changée

// __COUNTER__ dans la structure
   A a1, a2;
   print(a1.Method());
   print(a2.Method());                 // la valeur n'est pas changée

// __COUNTER__ dans la structure du modèle
   B<int> b1, b2;
   B<double> b3;
   print(b1.Method());
   print(b2.Method());                 // la valeur n'est pas changée
   print(b3.Method());                 // la valeur a changé

// __COUNTER__ dans la structure avec la fonction template
   C c1, c2;
   print(c1.Method<int>());
   print(c1.Method<double>());         // la valeur a changé
   print(c2.Method<int>());            // la même valeur que lors du premier appel à c1.Method<int>()

// --- regardons à nouveau __COUNTER__ dans la macro et la variable globale
   print(MACRO_COUNTER);  // la valeur a changé
   print(ExtGlobal2);
  }
// --- définit la valeur de la variable globale à l'aide de la macro __COUNTER__ après avoir défini les fonctions
int ExtGlobal2 = __COUNTER__;
//+------------------------------------------------------------------+

/* Résultat
   __COUNTER__=3
   InpVariable=0
   ExtVariable=1
   GlobalFunc()=5
   GlobalFunc()=5
   GlobalTemplateFunc<int>()=8
   GlobalTemplateFunc<int>()=8
   GlobalTemplateFunc<double>()=9
   GlobalFunc2()=7
   GlobalFunc2()=7
   a1.Method()=6
   a2.Method()=6
   b1.Method()=10
   b2.Method()=10
   b3.Method()=11
   c1.Method<int>()=12
   c1.Method<double>()=13
   c2.Method<int>()=12
   __COUNTER__=4
   ExtGlobal2=2

*/

Constantes Nommées

Constantes Mathématiques