Structure d'entrée - bibliothèque pour MetaTrader 5

Cette bibliothèque réduit les actions de routine lorsque l'on travaille avec des paramètres d'entrée.

OOP.

Prenons l'exemple d'un conseiller en trading. Il est raisonnable d'utiliser l'approche OOP lors de l'écriture de la logique de trading, car elle facilite l'intégration de l'EA dans des systèmes plus complexes.

D'un point de vue architectural, le conseiller OOP du testeur ressemble à ceci.

class SYSTEM
{
public:
  virtual void OnTick() {}

  // Les données d'entrée sont éditées sous forme de chaîne de caractères.
  virtual string ToString( void ) const = NULL;
  
  // Les données d'entrée sont spécifiées par une chaîne de caractères.
  virtual int FromString( const string Str ) = NULL;
};

SYSTEM* System = NULL;

void OnInit()
{
  System = new SYSTEM;
}

void OnTick()
{
  System.OnTick();
}

void OnDeinit( const int )
{
  delete System;
}

Cet EA ne fait rien. Mais lorsqu'il ne s'agit pas de logique de trading, mais seulement de travailler avec des paramètres d'entrée, le code se développe sérieusement, ce qui nuit à la lisibilité et augmente la probabilité d'erreur. En fait, vous devez effectuer un travail de routine désagréable.

Tous les paramètres d'entrée sont des chaînes de caractères.
.

Intéressons-nous un peu aux lignes mises en évidence dans le code.

La pratique commerciale montre qu'il est pratique d'enregistrer/de lire les paramètres d'entrée sous forme de chaîne de caractères, de sorte que vous puissiez voir rapidement et clairement les ensembles de paramètres d'entrée qui vous intéressent (que vous avez trouvés).

Amount = 1, Count = 2, Period = 3, Koef = 4.5, Log = 6.7, Flag = true
Amount = 2, Count = 3, Period = 4, Koef = 4.56, Log = 7.89, Flag = false

Par exemple, il y a deux ensembles de paramètres d'entrée dans le texte ci-dessus.

Les classiques de la POO pour travailler avec les paramètres d'entrée.

input int inAmount = 1;
input int inCount = 2;
input int inPeriod = 3;
  
input double inKoef = 4.56;
input double inLog = 7.89;
  
input bool inFlag = true;

struct INPUT_STRUCT
{
  int Amount;
  int Count;
  int Period;
  
  double Koef;
  double Log;
  
  bool Flag;
  
  string ToString( void ) const
  {
    string Str = NULL;

  #define  TOSTRING(A) Str += (::StringLen(Str) ? ", " : NULL ) + #A + " = " + (string)(this.A);
    TOSTRING(Amount);
    TOSTRING(Count);
    TOSTRING(Period);

    TOSTRING(Koef);
    TOSTRING(Log);
    
    TOSTRING(Flag);
  #undef  TOSTRING
    
    return(Str);
  }
  
  // N'a pas commencé à écrire.
  int FromString( const string Str )
  {
    return(0);
  }  
} inInputs = {inAmount, inCount, inPeriod, inKoef, inLog, inFlag};

#include <fxsaber\Input_Struct\Example_OnTick.mqh>

void EXAMPLE::OnTick( void )
{
  // Code du système...
 // this.Inputs contient les paramètres d'entrée.
}

Le code encombrant ci-dessus est le même EA vide, mais avec l'ajout (texte surligné) du travail avec les paramètres d'entrée. Le code est désagréable, et même sans l'implémentation de l'importante méthode INPUT_STRUCT::FromString.

Si vous souhaitez ajouter/supprimer un paramètre d'entrée, vous devrez apporter les modifications correspondantes à cinq endroits de ce code. Et c'est ainsi à chaque fois !

OOP-alternative de travail avec des paramètres d'entrée.
.

#include <fxsaber\Input_Struct\Input_Struct.mqh> // Structure des paramètres d'entrée.
INPUT_STRUCT inInputs;

MACROS_INPUT(int, Amount, 1);
MACROS_INPUT(int, Count, 2);
MACROS_INPUT(int, Period, 3);

MACROS_INPUT(double, Koef, 4.56);
MACROS_INPUT(double, Log, 7.89);

MACROS_INPUT(bool, Flag, true);

#include <fxsaber\Input_Struct\Example_OnTick.mqh>

void EXAMPLE::OnTick( void )
{
  // Code du système...
 // this.Inputs contient les paramètres d'entrée.
}

Il y a nettement moins de texte en surbrillance. En même temps, toutes les méthodes sont implémentées.

Scénarios d'utilisation.

• Temps minimal et probabilité d'erreur lors de la modification d'un ensemble de paramètres d'entrée.
• Plus de temps consacré à la logique commerciale qu'aux caractéristiques techniques.
• Sauvegarde/lecture des ensembles de paramètres d'entrée via une chaîne de caractères.
• Simplification significative de l'écriture de systèmes complexes (portefeuilles, etc.).
• Connexion facile d'algorithmes d'optimisation personnalisés.

Notez qu'avec l'approche OOP, beaucoup de texte répétitif peut être caché dans les fichiers mqh - comme c'est le cas dans les deux exemples ci-dessus. La POO peut également être concise.

Caractéristiques.