OOP, modelos e macros em mql5, sutilezas e usos - página 14

Novo comentário
 
Artyom Trishkin:

1. É melhor falar sobre algo no lugar onde está, em vez de pensar em como o moderador o faria. Caso contrário, tudo realmente se desfez em dois fios, e agora, mesmo que o moderador decida que a discussão deve estar lá ou não, é uma tarefa bastante trabalhosa mover a discussão normalmente com a preservação da ordem dos postos e seu significado.

2) Discutir as ações de um moderador não é todo espirro... Não é todo espirro, mas se você quiser desafiá-lo publicamente, seja para restaurar a ordem ou acalmar um frenesi. E se você tem uma opinião, quem o proíbe de expressá-la? Talvez sua opinião seja uma sugestão muito racional, mas você tem medo de dizê-lo, para não cair no menu não amado do moderador? Então isso é uma besteira :)

Obrigado pelo esclarecimento. Achei melhor ter a discussão em um fio à parte para não desorganizar as informações supostamente valiosas no fio principal. Se você decidir mudar os postos, eu discutirei para onde os mudará.

 
Ilya Malev:

Ainda não é como se você fosse um moderador, para determinar em qual linha o que é mais apropriado. E os moderadores já deixaram claro que a discussão das características deve ser em um ramo separado, ou seja, aqui, e não no ramo das características em si.

Em sua descrição, não está nada claro como se referir uniformemente a um método de classe por referência e por um valor do tipo T. Eu não sei do que você está falando, mas eu estava falando sobre isso mesmo.

Eis a situação: percebi que nem tudo pode ser adaptado às especificidades que os membros do fórum esperam ver nesse tópico. A discussão aqui é (e estava lá, então eu a mudei para cá) sobre um tópico bastante específico, que decidi separar em um fio à parte. Que haja mais geral e compreensível para a maioria das características, e aqui - aulas, formas complicadas de trabalhar com elas, incluindo macros (que quebra-cabeças para muitos).

 
Ilya Malev:

Obrigado pelo esclarecimento. Achei melhor ter a discussão em um fio à parte para não desorganizar as informações supostamente valiosas no fio principal. Se você decidir mudar os postos, eu discutirei para onde os mudará.

Vamos manter as coisas assim a partir de agora. Basta - se possível - copiar o exemplo que você está discutindo de lá para seu próprio posto, o que se refere a esse exemplo (estou tendo dificuldade em descobrir onde ele começou). Ou, se você não puder mais editar seu posto, então me diga em particular de onde colar o quê.

 
Artyom Trishkin:

Que a partir de agora continue assim. Basta - se possível - copiar o exemplo discutido de lá para o seu posto, que se refere a esse exemplo (é difícil para mim descobrir o que o iniciou aqui). Ou, se você ainda não pode editar seu posto, então me diga em particular de onde colar o quê.

Eu já copiei o código aqui desse tópico há um par de posts atrás, então nenhuma ação adicional é necessária, imho.

 
Ilya Malev:

Eu já copiei o código desse tópico há um par de posts atrás, portanto não são necessários passos extras.

Bom.

 

Atualização sobre o tema das interfaces através de modelos e estáticas. Para ser mais preciso, não interfaces, mas sim operações convenientemente parametrizáveis em tipos arbitrários, implementadas através de classes externas. Neste caso, a comparação (Comparador) e a fundição (Fundidor).

Abordei parcialmente as críticas anteriores, a classe "interface" (embora não seja uma interface) não é herdada da classe de parâmetros (tal método não pegou...), e sem usar o dynamic_cast, é claro. Esperemos que este modelo pareça mais lógico.

#property strict

#define  tnm typename
#define  ttt template<tnm T>
#define  ttf template<tnm F>
#define  ttr template<tnm R>
#define  tft template<tnm T,tnm F>
#define  up(P) (CheckPointer(P)!=POINTER_INVALID)

enum ECMP{ EQUAL=0, GREATER=1, LESSER=-1, UNDEF=INT_MAX };

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+

ttt class Type
 {
private:
  T item;
public:
  Type(){ ZeroMemory( item ); }
  Type *operator= (T par){ item = par; return &this; }
  T Get(){ return item; }
  
  ttf int operator!= ( Type<F>&par )
   { 
      int r = Comparer< Type< T > *, Type< F > * >::Get().Compare( &this, &par );
      
      if( r == UNDEF ) printf("Cannot compare %s to %s!",tnm(T),tnm(F));
      else{
        printf("%s (%s) to %s (%s) is %s",
          Caster<Type<T>*,string>::Get().Cast(&this), tnm(T),
          Caster<Type<F>*,string>::Get().Cast(&par),  tnm(F), Caster<ECMP,string>::Get().Cast((ECMP)r)); }
      return r; 
   }
 };

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+

tft class Comparer
 {
private:
  static Comparer *handle;
public:
  Comparer(){ if( handle == NULL ) handle = &this; }
  static Comparer *Get(){ return handle ; }
  virtual ECMP Compare( T, F ){ return UNDEF; }
 };

//---

tft Comparer *Comparer::handle=NULL;

tft class Caster
 {
private:
  static Caster *handle;
public:
  Caster(){ if( handle == NULL ) handle = &this; }
  static Caster *Get(){ return handle ; }
  virtual F Cast( T ){ F r; ZeroMemory(r); return r; }
 };

//---

tft Caster *Caster::handle=NULL;

ttt class ToStrCaster: public Caster<T,string>
 {
public:
  virtual string Cast( T ){ return "N/A"; }
 };

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+

class CmpIntToInt: public Comparer<Type<int>*,Type<int>*>
 {
public:
  virtual ECMP Compare( Type<int>* op1, Type<int>* op2 ){ return ECMP(up(op1)&&up(op2)?(op1.Get()>op2.Get())-(op1.Get()<op2.Get()):UNDEF); }
 }
citi;

class CmpDoubleToDouble: public Comparer<Type<double>*,Type<double>*>
 {
public:
  virtual ECMP Compare( Type<double>* op1, Type<double>* op2 ){ 
      return ECMP(up(op1)&&up(op2)?int(op1.Get()-op2.Get()>DBL_EPSILON)-int(op2.Get()-op1.Get()>DBL_EPSILON):UNDEF); }
 }
cdtd;

class CmpStrToStr: public Comparer<Type<string>*,Type<string>*>
 {
public:
  virtual ECMP Compare( Type<string>* op1, Type<string>* op2 ){ 
      return ECMP(up(op1)&&up(op2)?StringCompare(op1.Get(),op2.Get()):UNDEF); }
 }
csts;

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+

class IntToStrCaster: public ToStrCaster<Type<int>*>
 {
public:
  virtual string Cast( Type<int>* par ){ return up(par)?IntegerToString(par.Get()):NULL; }
 }
itsc;

class DoubleToStrCaster: public ToStrCaster<Type<double>*>
 {
public:
  virtual string Cast( Type<double>* par ){ return up(par)?DoubleToString(par.Get(),6):NULL; }
 }
dtsc;

class StringToStrCaster: public ToStrCaster<Type<string>*>
 {
public:
  virtual string Cast( Type<string>* par ){ return up(par)?par.Get():NULL; }
 }
stsc;

class ECMPToStrCaster: public ToStrCaster<ECMP>
 {
public:
  virtual string Cast( ECMP par ){ return EnumToString(par); }
 }
etsc;

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+

void OnStart()
 {
  Type<int> t1=AccountNumber(), t2=AccountLeverage();
  Type<double> t3=Ask, t4=Bid;
  Type<string> t5=_Symbol;
  
  t1!=t2;
  t4!=t3;
  t5!=t5;
  t1!=t3;
  t2!=t5;
 }


 

Quão realista é escrever uma macro para esta seção de código?

input int   InDealType_01=17;
input int   InDealType_02=22;
.....
input double InVolume_01 = 0.1;
input double InVolume_02 = 0.3;
.....    
   EA.AddDealsSettings(InDealType_01,InVolType_01,InVolume_01,InPrice_01,InVolCoeff_01,InClosePips_01,Mirror);
   EA.AddDealsSettings(InDealType_02,InVolType_02,InVolume_02,InPrice_02,InVolCoeff_02,InClosePips_02,Mirror);
   EA.AddDealsSettings(InDealType_03,InVolType_03,InVolume_03,InPrice_03,InVolCoeff_03,InClosePips_03,Mirror);
   EA.AddDealsSettings(InDealType_04,InVolType_04,InVolume_04,InPrice_04,InVolCoeff_04,InClosePips_04,Mirror);
   EA.AddDealsSettings(InDealType_05,InVolType_05,InVolume_05,InPrice_05,InVolCoeff_05,InClosePips_05,Mirror);
   EA.AddDealsSettings(InDealType_06,InVolType_06,InVolume_06,InPrice_06,InVolCoeff_06,InClosePips_06,Mirror);
   EA.AddDealsSettings(InDealType_07,InVolType_07,InVolume_07,InPrice_07,InVolCoeff_07,InClosePips_07,Mirror);
   EA.AddDealsSettings(InDealType_08,InVolType_08,InVolume_08,InPrice_08,InVolCoeff_08,InClosePips_08,Mirror);
   EA.AddDealsSettings(InDealType_09,InVolType_09,InVolume_09,InPrice_09,InVolCoeff_09,InClosePips_09,Mirror);
   EA.AddDealsSettings(InDealType_10,InVolType_10,InVolume_10,InPrice_10,InVolCoeff_10,InClosePips_10,Mirror);

Ainda não decidi o número de variáveis de entrada ( input ), estou cansado para corrigir a seção alocada, a macro para uma linha não é um problema, mas como multiplicá-la para 10-15 linhaseu não sei

 
Igor Makanu:

Quão realista é fazer uma macro para esta seção de código?

ainda não decidiram o número de variáveis de entrada ( input ), cansados de corrigir a peça selecionada, a macro para uma linha não é um problema, mas como multiplicá-la para 10-15 linhas eu não sei

Devo dizer de imediato que não o verifiquei no µl, apenas o passei por um pré-processador pardo para testes, o µl tem peculiaridades, se algo precisa ser afinado.

#define  ARGS HLP(InDealType_)    \
             HLP(InVolType_),    \
             HLP(InVolume_),     \
             HLP(InPrice_),      \
             HLP(InVolCoeff_),   \
             HLP(InClosePips_),  \
             Mirror
#define _CAT(L, R) L##R
#define  CAT(L, R) _CAT(L, R)
#define  HLP(ARG)  CAT(ARG, INDEX)

#define  INDEX 01
EA.AddDealsSettings(ARGS);
#undef  INDEX
#define  INDEX 02
EA.AddDealsSettings(ARGS);
#undef  INDEX
#define  INDEX 03
EA.AddDealsSettings(ARGS);
#undef  INDEX

obteve a saída (gcc -E):

EA.AddDealsSettings(InDealType_01 InVolType_01, InVolume_01, InPrice_01, InVolCoeff_01, InClosePips_01, Mirror);
EA.AddDealsSettings(InDealType_02 InVolType_02, InVolume_02, InPrice_02, InVolCoeff_02, InClosePips_02, Mirror);
EA.AddDealsSettings(InDealType_03 InVolType_03, InVolume_03, InPrice_03, InVolCoeff_03, InClosePips_03, Mirror);

argumentos adicionais que você/doará para a lista ARGS.

 
Igor Makanu:

Quão realista é escrever uma macro para esta seção de código?

Ainda não decidi o número de variáveis de entrada ( input ), estou cansado para corrigir a seção alocada, a macro para uma linha não é um problema, mas como multiplicá-la para 10-15 linhas eu não sei

#define  TEST(dId) EA.AddDealsSettings(InDealType_##dId,InVolType_##dId,InVolume_##dId,InPrice_##dId,InVolCoeff_##dId,InClosePips_##dId,Mirror)
#define  TEST2(d1,d2) do {TEST(d1);TEST(d2);} while(false)
#define  TEST3(d1,d2,d3) do{TEST2(d1,d2);TEST(d3);} while(false)
#define  TEST4(d1,d2,d3,d4) do{TEST2(d1,d2);TEST(d3,d4);} while(false)
....
#define  TEST100(d1,...d100) do{TEST50(d1,...d50);TEST50(d51,...d100);}while(false)

void OnStart()
  {
....
TEST4(01,02,03,04);
......
}

Até agora, só assim surgiu. Se os desenvolvedores tivessem adicionado um número variável de parâmetros, como em C, ele poderia ser mais curto.

 
Vladimir Simakov:

Até agora, isto é tudo o que encontrei. Se os desenvolvedores aparafusassem um número variável de parâmetros, como em C, seria possível torná-lo mais curto.

Algo que eu compliquei em demasia )).

E deixá-los usar o primeiro, provavelmente é o melhor.

#define  TEST(dId)
Não é um problema escrever o TESTE várias vezes.
1...789101112131415161718192021...28
Novo comentário