Perguntas sobre OOP em MQL5 - página 48

Novo comentário
 
Alexey Navoykov:
O principal é que deve ser de nível superior ao C++, e o código deve ser mais simples e lacônico. Mas na verdade é o contrário. O código em MQL é muito mais pesado e desajeitado. Você tem que triturar muitas coisas.
Faz-me lembrar o WinApi por sensação)))
 

qualquer pessoa forte para mostrar como portar para MQL :

https://ru.wikipedia.org/wiki/Хранитель (padrão de design) / C++ versão não-padrão do padrão

tentou de frente, algo deu errado com as descrições para frente

//+------------------------------------------------------------------+
class Originator
{
public:
   int state;
   Originator() : state(0)    {                             }
   class Memento;
   Memento* getMemento();
   void setState(int s)       { state = s;                  }
   void dumpState()           { printf("State: %i", state); }
   class Memento
   {
   public:
      class Originator;
      int state;
      Originator* org;
      Memento() : state(0)    {                             }
      void restoreState();
   };
};
//+------------------------------------------------------------------+
Originator::Memento* Originator::getMemento()
{
   Originator::Memento* m = new Originator::Memento();
//   m.org = this;
//   m.state = state;
//   m->org = this;
//   m->state = state;
   return m;
}
//+------------------------------------------------------------------+
void Originator::Memento::restoreState()
{
//   org->state = state;
}
//+------------------------------------------------------------------+
void OnStart()
{

}
//+------------------------------------------------------------------+
 
Igor Makanu:

qualquer pessoa forte para mostrar como portar para MQL :

https://ru.wikipedia.org/wiki/Хранитель (padrão de design) / C++ versão não-padrão do padrão

tentou de frente, algo deu errado com as descrições para frente

Minha versão:

//+------------------------------------------------------------------+
class Originator
  {
public:
   int               state;
                     Originator() : state(0)    {                             }
   class             Memento;
   Memento*          getMemento();
   void              setState(int s)       { state = s;                  }
   void              dumpState()           { printf("State: %i", state); }
   class Memento
     {
   public:
      //class          Originator;
      int            state;
      Originator*    org;
                     Memento() : state(0)    {                             }
      void           restoreState();
     };
  };
//+------------------------------------------------------------------+
Originator::Memento* Originator::getMemento()
  {
   Originator::Memento* m = new Originator::Memento();
   m.org = GetPointer(this);
   m.state = state;
   return m;
  }
//+------------------------------------------------------------------+
void Originator::Memento::restoreState()
  {
   this.state = state;
  }
//+------------------------------------------------------------------+
void OnStart()
  {
   Originator org_obj;
   Originator::Memento* ptr_mem_obj = org_obj.getMemento();
   delete ptr_mem_obj;
  }
//+------------------------------------------------------------------+
 
Denis Kirichenko:

Minha versão:

ótimo! bom exemplo!

Obrigado!

 
Alexey Navoykov:
O principal é que deve ser de nível superior ao C++, e o código deve ser mais simples e lacônico, mas na verdade é o contrário. O código em MQL é muito mais pesado e desajeitado. Muitas coisas têm que ser mutiladas.

Não, isso é uma piada curta). Talvez você tenha tido o curso errado na vida, talvez devesse ter ido para uma escola técnica culinária.

 
Alexey Navoykov:
Na verdade, não importa a linguagem do MQL. O principal é que ele deve ser mais alto do que C++, e o código nele deve ser mais simples e conciso. Mas na verdade é o oposto. O código no MQL é muito mais incômodo e desajeitado. Muitas coisas têm que ser esmagadas e manipuladas.

O principal problema aqui é a própria portabilidade, não mesmo a portabilidade em geral, mas como se pode chegar a tal idéia.

 

Isto é o que acontece quando crianças com mentes imaturas aprendem STL.

E a MQL - seus criadores mostraram perfeitamente que eles, mais do que ninguém, compreendem os problemas reais dos programadores e os desafios da programação. Se você não entende, talvez você realmente devesse pensar em uma escola técnica culinária?

O principal problema na MQL, o principal e único, é pensar através do algoritmo que garante a execução confiável da estratégia. Não é um problema lingüístico de forma alguma. Nenhuma língua ou sintaxe pode fornecer isto por si só. É por isso que sua bisbilhotice no nível de sintaxe é uma brilhante demonstração de que você ainda está em um nível de jardim de infância. Isto é, você ainda nem aprendeu a codificar, nem a chegar ao estágio de desenvolver algoritmos estáveis. Mas ao menos você tem... um vagão inteiro.

 
Igor Makanu:

excelente! bom exemplo!

Obrigado!

class Originator
  {
   int               state;
public:
   class Memento;
   Originator() : state(0){}
   Memento*          getMemento()      {return new Memento(&this);}
   void              setState(int s)   {state=s;}
   int               State()           {return state;}
   void              dumpState()       {printf("State: %i", state);}
///////////////////////////////////////////////////////////
   class Memento{
      int            state;
      Originator*    org;
      public:
                        Memento(Originator* mOrg):state(mOrg.State()),org(mOrg){}
         void           restoreState() {org.setState(state);}
   };
///////////////////////////////////////////////////////////
  };

void OnStart()
  {
   Originator org_obj;
   Originator::Memento* ptr_mem_obj = org_obj.getMemento();
   org_obj.setState(6);
   org_obj.dumpState();
   ptr_mem_obj.restoreState();
   org_obj.dumpState();
   delete ptr_mem_obj;
  }

Isso parece certo.

 
Vladimir Simakov:

Este parece ser o caminho certo

OK, eu vou salvar, eu precisava testar o princípio do trabalho, talvez isto seja o que eu estava procurando - um código para testador e para EA de trabalho, que pode salvar seu estado, e no testador ao contrário, não desperdiçar recursos em "gestos extras" - parte de tal padrão pode ser coberto por #ifdef -ami ;)

 

Padrão único, se alguém precisar dele, é claro:

class Alone{
private:
   int state;        
   Alone():state(0){}
public:
   static Alone* Get(){
      static Alone alone;
      return &alone;}
   int State() {return(state);}
   void State(int _state) {state=_state;}
};

void OnStart()
  {
   Test(123);
   Alone* test=Alone::Get();
   Print(test.State());
  }
  
void Test(int x){
   Alone* test=Alone::Get();
   test.State(x);}

Eu tenho desejado um bom desde a cerveja))))

Envelhecendo, eu acho))))

1...414243444546474849505152535455...96
Novo comentário