Preguntas sobre POO en MQL5

Vladimir Simakov 2020.04.21 14:04 #471

Alexey Navoykov:
En realidad no importa cómo es el lenguaje MQL, lo principal es que se supone que es de más alto nivel que C++, y el código en él debería ser más sencillo y lacónico. Pero en realidad es al revés, el código en MQL es mucho más engorroso y torpe, hay que muletear muchas cosas.

Me recuerda a WinApi por la sensación)))

Igor Makanu 2020.05.15 19:15 #472

alguien fuerte para mostrar como portar a MQL :

https://ru.wikipedia.org/wiki/Хранитель (patrón de diseño)/Versión no convencional del patrón en C++

lo intentó de frente, algo salió mal con las descripciones de los delanteros

//+------------------------------------------------------------------+
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()
{

}
//+------------------------------------------------------------------+

Denis Kirichenko 2020.05.15 19:44 #473

Igor Makanu:

alguien fuerte para mostrar como portar a MQL :

https://ru.wikipedia.org/wiki/Хранитель (patrón de diseño) / Versión no estándar del patrón en C++

lo intentó de frente, algo salió mal con las descripciones de los delanteros

Mi versión:

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

Igor Makanu 2020.05.15 19:57 #474

Denis Kirichenko:

Mi versión:

¡genial! ¡buen ejemplo!

Gracias.

Dmitry Fedoseev 2020.05.16 02:46 #475

Alexey Navoykov:
Lo principal es que se supone que es de más alto nivel que C++, y el código en él debería ser más sencillo y lacónico. Pero en realidad es al revés. El código en MQL es mucho más engorroso y torpe. Hay que muletear muchas cosas.

No, es un chiste corto). Quizá te equivocaste de carrera en la vida, quizá deberías haber ido a una escuela técnica culinaria.

Dmitry Fedoseev 2020.05.16 02:47 #476

Alexey Navoykov:
En realidad, no importa el aspecto del lenguaje MQL. Lo principal es que se supone que es de más alto nivel que C++, y el código en él debería ser más simple y conciso. Pero en realidad es lo contrario. El código en MQL es mucho más engorroso y torpe. Hay que muletear y manipular muchas cosas.

El principal problema aquí es el porteo en sí, ni siquiera el porteo en general, sino cómo se puede llegar a esa idea.

Dmitry Fedoseev 2020.05.16 02:50 #477

Esto es lo que ocurre cuando los niños con mentes inmaduras aprenden STL.

Y MQL - sus creadores acaban de demostrar perfectamente que ellos, más que nadie, entienden los problemas reales de los programadores y los retos de la programación. Si no lo entiendes, quizás deberías pensar en una escuela técnica culinaria.

El principal problema en MQL, el principal y el único, es pensar en el algoritmo que asegura la ejecución fiable de la estrategia. No es un problema de idioma en absoluto. Ningún lenguaje o sintaxis puede proporcionar esto por sí mismo. Por eso, tu hurgar en el nivel de la sintaxis es una brillante demostración de que todavía estás en un nivel de parvulario. Es decir, ni siquiera has aprendido a codificar, ni a llegar a la fase de desarrollo de algoritmos estables. Pero al menos tienes... un vagón entero.

Quién, quién, sino yo Cualquier pregunta de los Preguntas de los principiantes

Vladimir Simakov 2020.05.16 17:35 #478

Igor Makanu:

¡excelente! ¡buen ejemplo!

Gracias.

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

Eso parece correcto

Igor Makanu 2020.05.16 17:40 #479

Vladimir Simakov:

Este parece ser el camino correcto

OK, lo guardaré, necesitaba probar el principio de trabajo, tal vez esto es lo que estaba buscando - un código para el probador y para el EA de trabajo, que puede guardar su estado, y en el probador por el contrario no gastar recursos en "gestos extra" - parte de tal patrón puede ser cubierto por #ifdef -ami ;)

[Archivo] ¡Aprende a ganar A la consideración de Opciones

Vladimir Simakov 2020.05.16 18:20 #480

Patrón único, si alguien lo necesita por supuesto:

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

Tengo ganas de una buena desde la cerveza)))

Envejeciendo supongo))))

Preguntas sobre POO en MQL5 - página 48