Questions sur la POO dans MQL5

Vladimir Simakov 2020.04.21 14:04 #471

Alexey Navoykov:
La chose principale est qu'il est censé être d'un niveau plus élevé que le C++, et que le code devrait être plus simple et plus laconique. Mais en fait, c'est l'inverse. Le code dans MQL est beaucoup plus lourd et maladroit. Vous devez concasser beaucoup de choses.

Cela me rappelle WinApi par sensation))))

Igor Makanu 2020.05.15 19:15 #472

quelqu'un de fort pour montrer comment porter vers MQL :

https://ru.wikipedia.org/wiki/Хранитель (modèle de conception) / Version C++ non conventionnelle du modèle

l'a essayé de front, quelque chose a mal tourné avec les descriptions de l'avant.

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

quelqu'un de fort pour montrer comment porter vers MQL :

https://ru.wikipedia.org/wiki/Хранитель (modèle de conception) / version non standard du modèle en C++

l'a essayé de front, quelque chose a mal tourné avec les descriptions de l'avant.

Ma version :

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

Ma version :

super ! bon exemple !

Merci !

Dmitry Fedoseev 2020.05.16 02:46 #475

Alexey Navoykov:
Le principal est qu'il est censé être d'un niveau plus élevé que le C++, et que le code qu'il contient devrait être plus simple et plus laconique. Mais en fait, c'est l'inverse. Le code dans MQL est beaucoup plus lourd et maladroit. Beaucoup de choses doivent être béquillées.

Nah, c'est une courte blague.) Peut-être que tu t'es trompé de matière principale dans la vie, peut-être que tu aurais dû aller dans une école technique culinaire.

Dmitry Fedoseev 2020.05.16 02:47 #476

Alexey Navoykov:
En fait, l'apparence du langage MQL n'a pas vraiment d'importance. L'essentiel est qu'il est censé être plus haut niveau que le C++, et que le code qu'il contient devrait être plus simple et plus concis. Mais en fait, c'est le contraire. Le code en MQL est beaucoup plus lourd et maladroit. Beaucoup de choses doivent être béquillées et manipulées.

Le principal problème ici est le portage lui-même, pas même le portage en général, mais comment on peut arriver à une telle idée.

Dmitry Fedoseev 2020.05.16 02:50 #477

C'est ce qui arrive quand des enfants à l'esprit immature apprennent la STL.

Et MQL - ses créateurs ont parfaitement démontré qu'ils comprennent, plus que quiconque, les problèmes réels des programmeurs et les défis de la programmation. Si vous ne le comprenez pas, peut-être devriez-vous envisager une école technique culinaire ?

Le principal problème dans MQL, le principal et l'unique, est de réfléchir à l'algorithme qui assure l'exécution fiable de la stratégie. Ce n'est pas du tout un problème de langue. Aucun langage ou syntaxe ne peut fournir cela par lui-même. C'est pourquoi le fait que vous fouilliez au niveau de la syntaxe démontre clairement que vous en êtes encore au niveau de la maternelle. C'est-à-dire que vous n'avez même pas appris à coder, ni même à développer des algorithmes stables. Mais vous avez beaucoup d'attitude... un wagon entier.

MT5 est destiné aux Il ne sert à GLUCK ? ! Gestion

Vladimir Simakov 2020.05.16 17:35 #478

Igor Makanu:

excellent ! bon exemple !

Merci !

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

Cela semble correct.

Igor Makanu 2020.05.16 17:40 #479

Vladimir Simakov:

Cela semble être la bonne méthode

OK, je vais le sauvegarder, j'avais besoin de tester le principe de travail, peut-être que c'est ce que je cherchais - un code pour le testeur et pour l'EA en fonctionnement, qui peut sauvegarder son état, et dans le testeur au contraire ne pas gaspiller de ressources sur des "gestes supplémentaires" - une partie de ce modèle peut être couverte par #ifdef -ami ;)

Toute question de débutant, Comment j'ai assemblé mon Il n'y a pas

Vladimir Simakov 2020.05.16 18:20 #480

Patron unique, si quelqu'un en a besoin bien sûr :

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

J'en ai envie d'une bonne depuis la bière))))

Je me fais vieux je suppose))))

Questions sur la POO dans MQL5 - page 48