Estrutura_de_entrada - biblioteca para MetaTrader 5

Essa biblioteca reduz as ações de rotina ao trabalhar com parâmetros de entrada.

OOP.

Como exemplo de uso, vamos usar um consultor de negociação. É razoável usar a abordagem OOP ao escrever a lógica de negociação, pois isso facilita a incorporação do EA em sistemas mais complexos.

Arquitetonicamente, o consultor OOP para o Testador tem a seguinte aparência.

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

  // Os dados de entrada são exibidos como uma string.
  virtual string ToString( void ) const = NULL;
  
  // Os dados de entrada são especificados por uma string.
  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;
}

Esse EA não faz nada. Mas quando não se trata de lógica de negociação, mas apenas de trabalhar com parâmetros de entrada, o código cresce seriamente, o que piora a legibilidade e aumenta a probabilidade de erro. Na verdade, você é obrigado a realizar um trabalho de rotina desagradável.

Todos os parâmetros de entrada como uma cadeia de caracteres.
.

Vamos nos desviar um pouco para as linhas destacadas no código.

A prática comercial mostra que é conveniente salvar/ler os parâmetros de entrada em forma de string, para que você possa ver rápida e claramente os conjuntos de parâmetros de entrada nos quais está interessado (encontrados).

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

Por exemplo, há dois conjuntos de parâmetros de entrada no texto acima.

Clássicos de OOP para trabalhar com parâmetros de entrada.

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ão comecei a escrever.
  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 )
{
  // Código do sistema...
 // this.Inputs contém parâmetros de entrada.
}

O código complicado acima é o mesmo EA vazio, mas apenas com a adição (texto destacado) de trabalho com parâmetros de entrada. O código é desagradável, e mesmo sem a implementação do importante método INPUT_STRUCT::FromString.

Se você quiser adicionar/remover um parâmetro de entrada, terá que fazer as alterações correspondentes em cinco locais desse código. E é sempre assim!

Alternativa de OOP para trabalhar com parâmetros de entrada.
.

#include <fxsaber\Input_Struct\Input_Struct.mqh> // Estrutura dos parâmetros de entrada.
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 )
{
  // Código do sistema...
 // this.Inputs contém parâmetros de entrada.
}

O texto destacado é visivelmente menor. Ao mesmo tempo, todos os métodos estão implementados.

Cenários de uso.

• Tempo mínimo e probabilidade de erro ao alterar um conjunto de parâmetros de entrada.
• Mais tempo dedicado à lógica comercial em vez de recursos técnicos.
• Salvar/ler conjuntos de parâmetros de entrada via string.
• Simplificação significativa da criação de sistemas complexos (portfólios, etc.).
• Fácil conexão de algoritmos de otimização personalizados.

Observe que, com a abordagem OOP, muito texto repetitivo pode ser ocultado nos arquivos mqh, como é feito nos dois exemplos acima. A OOP também pode ser concisa.

Recursos.