Domande su OOP in MQL5 - pagina 48

Nuovo commento
 
Alexey Navoykov:
La cosa principale è che si suppone che sia di livello superiore al C++, e il codice in esso dovrebbe essere più semplice e laconico. Ma in realtà è il contrario. Il codice in MQL è molto più macchinoso e goffo. Bisogna fare un sacco di calcoli.
Mi ricorda WinApi a sensazione)))
 

qualcuno forte per mostrare come portare a MQL :

https://ru.wikipedia.org/wiki/Хранитель (design pattern)/Versione C++ non convenzionale del pattern

provato a testa alta, qualcosa è andato storto con le descrizioni in avanti

//+------------------------------------------------------------------+
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:

qualcuno forte per mostrare come portare a MQL :

https://ru.wikipedia.org/wiki/Хранитель (design pattern) / C++ versione non standard del pattern

provato a testa alta, qualcosa è andato storto con le descrizioni in avanti

La mia versione:

//+------------------------------------------------------------------+
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:

La mia versione:

grande! buon esempio!

Grazie!

 
Alexey Navoykov:
La cosa principale è che si suppone che sia di livello superiore al C++, e il codice in esso dovrebbe essere più semplice e laconico. Ma in realtà è il contrario. Il codice in MQL è molto più macchinoso e goffo. Molte cose devono essere stampate.

No, è una battuta breve). Forse hai sbagliato indirizzo nella vita, forse avresti dovuto frequentare una scuola tecnica culinaria.

 
Alexey Navoykov:
In realtà, non importa quale sia il linguaggio MQL. La cosa principale è che si suppone che sia più di alto livello rispetto al C++, e il codice in esso dovrebbe essere più semplice e conciso. Ma in realtà è l'opposto. Il codice in MQL è molto più macchinoso e goffo. Molte cose devono essere manipolate.

Il problema principale qui è il porting stesso, nemmeno il porting in generale, ma come si può arrivare a un'idea del genere.

 

Questo è quello che succede quando i bambini con menti immature imparano STL.

E MQL - i suoi creatori hanno dimostrato perfettamente che loro, più di chiunque altro, capiscono i problemi reali dei programmatori e le sfide della programmazione. Se non lo capisci, forse dovresti davvero pensare a una scuola tecnica culinaria?

Il problema principale nel MQL, il principale e l'unico, è quello di pensare attraverso l'algoritmo che assicura l'esecuzione affidabile della strategia. Non è affatto un problema di lingua. Nessun linguaggio o sintassi può fornire questo da solo. È per questo che il tuo frugare a livello di sintassi è una brillante dimostrazione che sei ancora ad un livello di scuola materna. Cioè non hai nemmeno imparato a codificare, per non arrivare alla fase di sviluppo di algoritmi stabili. Ma almeno hai... un intero vagone.

 
Igor Makanu:

eccellente! buon esempio!

Grazie!

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;
  }

Mi sembra giusto

 
Vladimir Simakov:

Questo sembra essere il modo giusto

OK, lo salverò, avevo bisogno di testare il principio di lavoro, forse questo è quello che stavo cercando - un codice per il tester e per l'EA funzionante, che può salvare il suo stato, e nel tester al contrario non sprecare risorse su "gesti extra" - parte di tale modello può essere coperto da #ifdef -ami ;)

 

Modello singolo, se qualcuno ne ha bisogno, naturalmente:

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);}

Ho una voglia matta di una buona birra)))

Invecchiando credo))))

1...414243444546474849505152535455...96
Nuovo commento