Questions sur la POO dans MQL5 - page 37

 
Koldun Zloy:

Tout cela est compréhensible. Il n'est pas clair pourquoiSetSaveRequired() etGetSaveRequired() sont non-statiques, mais écrivent dans une variable statique.

Je ne comprends pas, c'est pourquoi j'ai demandé de l'aide. J'utilise rarement les modificateurs, plus intuitifs, mais je veux toujours la meilleure solution.

Laissez-moi l'essayer dans le code, c'est comme ça

//+------------------------------------------------------------------+
interface IStrategy
{  double      Strategy();
   bool        Finalize(); };
//+------------------------------------------------------------------+
class CStrategy: public IStrategy
{
public:
   bool              GetSaveRequired() { return(CStrategy::f_save_required); CStrategy::f_save_required = false;  }
protected:
   static bool       f_save_required;
   double            ProfitStrategy;
   void              SetSaveRequired() { CStrategy::f_save_required = true;                                       }
   void              RunStrategy();
   virtual void      NextStepStrategy();
   void              EndStrategy();
};

//____________________________________________________________________
void CStrategy::RunStrategy(void)
{  ProfitStrategy = 0.0;
   SetSaveRequired();
//...........    
}
//____________________________________________________________________
void CStrategy::EndStrategy(string func)
{ //...........    
   SetSaveRequired();
}
//____________________________________________________________________
#define CLASS(NAME) class NAME : public CStrategy{\
public:\
   NAME(SSettingsForOrder &set)  { m_setting = set;}\
   ~NAME()                       { delete m_order; }\
   virtual void NextStepStrategy();}
//+------------------------------------------------------------------+
CLASS(CStrategy_XXX);
CLASS(CStrategy_YYY);
CLASS(CStrategy_ZZZ);

void CStrategy_XXX::NextStepStrategy(void) { SetSaveRequired();   //...........     }
void CStrategy_YYY::NextStepStrategy(void) { SetSaveRequired();   //...........     }
void CStrategy_ZZZ::NextStepStrategy(void) { SetSaveRequired();   //...........     }


publicGetSaveRequired() est utilisé dans une classe pour gérer tout ce zoo de stratégies

avec ce modèle, je n'écris que la méthodeNextStepStrategy - il n'y a que la méthode qui change pour TC, tout le reste est identique, donc dans la classe de base CStrategy je rassemble toutes les méthodes et tous les champs - il n'y en a pas beaucoup

ZS : avec mon dos je sens que pas as mon code, mais il va certainement fonctionner et ne créera pas de doublons de la variablef_save_required;

 
Igor Makanu:

C'est ce que je ne comprends pas, c'est pourquoi j'ai demandé de l'aide. J'utilise rarement les modificateurs, je les utilise plus intuitivement, mais comme toujours, je veux la meilleure solution.

Laissez-moi l'essayer dans le code, c'est comme ça


publicGetSaveRequired() est utilisé dans une classe pour gérer tout ce zoo de stratégies

avec ce modèle, je n'écris que la méthodeNextStepStrategy - il n'y a que la méthode qui change pour TC, tout le reste est identique, donc dans la classe de base CStrategy je rassemble toutes les méthodes et tous les champs - il n'y en a pas beaucoup

ZS : avec mon dos je sens que pas as mon code, mais il va certainement fonctionner et ne créera pas de doublons de la variablef_save_required;

Je supprimerais complètement ces fonctions.

Toutes les fonctions qui ne modifient pas la structure, en font des constantes.

Toutes les fonctions non constantes doivent activer l'indicateur d'écriture.

J'ajouterais également la fonction Save( int fileHandle ). Cette fonction doit écrire la structure et réinitialiser l'indicateur.

Vous pouvez créer une fonction statique pour obtenir l'état du drapeau.

if( CStrategy::GetSaveRequired() )
{
   int fileHandle = FileOpen( ... );
   for( int i = 0; i < 10; i++ )
   {
      strategies[i].Save( fileHandle );
   }
   FileClose( fileHandle );
}
 
Koldun Zloy:

Je supprimerais complètement ces fonctions.

Rendez constantes toutes les fonctions qui ne modifient pas la structure.

Toutes les fonctions non constantes doivent activer l'indicateur d'écriture.

Je vous le dis, j'ai du mal avec les modificateurs en général.


SZY : en attendant ce qui se passe en général sur le web dans les discussions sur la programmation - il y avait un article sur la const sur hobber le mois dernier, la signification - cette const n'est pas nécessaire, regardez le code assembleur n'est pas différent sans const - le compilateur va tout enlever ((

 
Igor Makanu:

Je vous le dis, j'ai du mal avec les modificateurs en général.

J'ai cherché sur Internet, j'ai lu, quelque chose a encore mal tourné...

class A {
private:
  int x;
public:
  void f(int v) const { Print("const");                  }
  void f(const int v) { x = v; Print("(const) x = v ");  }
//  void f(int v)       { x = v; Print("x = v ");          } // 'f' - function already defined and has body     
};

A a;
//+------------------------------------------------------------------+
void OnStart()
{ 
   int y       = 1;
   const int z = 2;
   a.f(3);
   a.f(y);
   a.f(z); 
 }
//+------------------------------------------------------------------+

2019.09.13 21:10:54.316 tst (EURUSD,H1) x = v

2019.09.13 21:10:54.316 tst (EURUSD,H1) x = v

2019.09.13 21:10:54.316 tst (EURUSD,H1) x = v

Je m'attendais à obtenirPrint("const") au moins une fois ;
 
Igor Makanu:

J'ai cherché sur Google, j'ai lu, quelque chose a encore mal tourné...

2019.09.13 21:10:54.316 tst (EURUSD,H1) x = v

2019.09.13 21:10:54.316 tst (EURUSD,H1) x = v

2019.09.13 21:10:54.316 tst (EURUSD,H1) x = v

Je m'attendais à obtenirPrint("const") au moins une fois ;
class A {
private:
  int x;
public:
  void f(int v) const { Print("const");                  }
  void f(const int v) { x = v; Print("(const) x = v ");  }
//  void f(int v)       { x = v; Print("x = v ");          } // 'f' - function already defined and has body     
};

A a;
const A b;
//+------------------------------------------------------------------+
void OnStart()
{ 
   int y       = 1;
   const int z = 2;
   a.f(3);
   a.f(y);
   a.f(z);
   b.f(3);
   b.f(y);
   b.f(z);
 }
Il s'agit d'une surcharge pour une classe constante.
 
Vladimir Simakov:
Il s'agit d'une surcharge pour une classe constante.

Hmmm... c'est vrai, j'ai passé près d'une demi-heure à lire le hub et les forums, mais je n'ai pas réussi à m'y retrouver.

Merci ! Maintenant je l'ai

Il y a toujours le soupçon d'un tel exemple :

class A {
private:
  int x;
public:
  void f(int v) const { Print("const");                  }
  const void f(int v) { x = v; Print("(const) x = v ");  }

};

A a;
const A b;
//+------------------------------------------------------------------+
void OnStart()
{ 
   int y       = 1;
   const int z = 2;
   a.f(3);
   a.f(y);
   a.f(z);
   b.f(3);
   b.f(y);
   b.f(z);
 }

2019.09.13 22:04:34.295 tst (EURUSD,H1) (const) x = v

2019.09.13 22:04:34.295 tst (EURUSD,H1) (const) x = v

2019.09.13 22:04:34.295 tst (EURUSD,H1) (const) x = v

2019.09.13 22:04:34.295 tst (EURUSD,H1) const

2019.09.13 22:04:34.295 tst (EURUSD,H1) const

2019.09.13 22:04:34.295 tst (EURUSD,H1) const


a donné les mêmes valeurs, mais le point est tout à fait différent ? - Alors vous avez à nouveau besoin de l'aide de la salle.
 
Je suis assis à une conférence sur la programmation opérationnelle en ce moment. Peut-être que je partagerai quelque chose d'utile avec vous ;)).
Je peux télécharger le cours actuel. Jusqu'à présent, bien sûr, les choses banales.
 
Nikolai Semko:
J'assiste à une conférence sur la programmation opérationnelle en ce moment. (Je partagerai peut-être ce que j'apprendrai))
Je peux télécharger la conférence en cours. Jusqu'à présent, bien sûr, les choses banales.

Eh bien, votre cours est très probablement en charabia, alors qu'ici vous ne pouvez presque rien apprendre en russe, vous avez fait le tour d'Internet pour la troisième fois... la situation générale est sinistre comme ici sur le forum, les vrais programmeurs - pas plus de 10 personnes sur la ressource, le reste sont des geeks

Ok, la situation générale s'est éclaircie avec const, j'ai travaillé avec le reste des modificateurs, donc j'ai beaucoup de théorie ... J'ai besoin de l'appliquer, mais je me sens comme un étudiant ;)))

 
Igor Makanu:

Eh bien, votre cours est très probablement en charabia, alors qu'ici vous ne pouvez presque rien apprendre en russe, vous avez fait le tour d'Internet pour la troisième fois... la situation générale est sinistre comme ici sur le forum, les vrais programmeurs - pas plus de 10 personnes sur la ressource, le reste sont des geeks

Ok, la situation générale s'est éclaircie avec const, j'ai travaillé avec le reste des modificateurs, donc j'ai beaucoup de théorie ... Je me sens comme un étudiant ;))).

Oui, je suis aussi dans une situation similaire. Il n'est pas difficile d'apprendre, il est plus difficile de se recycler, de briser les vieilles habitudes. Je n'arrive toujours pas à me débarrasser de nombreuses mauvaises habitudes de la programmation procédurale.

 
Igor Makanu:

Je voudrais un exemple, je vous le dis, je ne suis pas du tout bon avec les modificateurs.


SZY : d'ailleurs en général l'horreur ce qui se passe dans le web dans la discussion de programmation - ici il y avait un article sur const sur hubra le mois dernier, la signification - oui nous n'avons pas besoin de ce const, regardez code assembleur ne diffère pas que sans const - le compilateur va supprimer tout (((

Vous pouvez simplement oublier les constantes et la statique pour le moment. Sur les interfaces aussi.

Et quand tout est prêt, regardez et marquez quelque chose comme une statique et quelque chose comme une constante. Et vous pouvez oublier complètement les interfaces.

Raison: