Domande su OOP in MQL5 - pagina 37

 
Koldun Zloy:

Tutto questo è comprensibile. Non è chiaro perchéSetSaveRequired() eGetSaveRequired() non sono statici, ma scrivono su una variabile statica.

Non lo capisco, è per questo che ho chiesto aiuto. Uso raramente i modificatori, più intuitivi, ma voglio sempre la soluzione migliore.

Fatemi provare nel codice, è così

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


La funzione pubblicaGetSaveRequired() è utilizzata in una classe per gestire tutto questo zoo di strategie

Con questo pattern scrivo solo il metodoNextStepStrategy - solo in esso cambia per TC, tutto il resto è lo stesso, così nella classe base CStrategy raccolgo tutti i metodi e tutti i campi - non sono molto

ZS: con la mia schiena sento che non ace il mio codice, ma funzionerà sicuramente e non creerà duplicati della variabilef_save_required;

 
Igor Makanu:

Questo è quello che non capisco, è per questo che ho chiesto aiuto. Uso raramente i modificatori, li uso più intuitivamente, ma come sempre voglio la soluzione migliore

Fatemi provare nel codice, è così


La funzione pubblicaGetSaveRequired() è utilizzata in una classe per gestire tutto questo zoo di strategie

Con questo pattern scrivo solo il metodoNextStepStrategy - solo in esso cambia per TC, tutto il resto è lo stesso, così nella classe base CStrategy raccolgo tutti i metodi e tutti i campi - non sono molto

ZS: con la mia schiena sento che non ace il mio codice, ma funzionerà sicuramente e non creerà duplicati della variabilef_save_required;

Io eliminerei del tutto queste funzioni.

Tutte le funzioni che non cambiano la struttura, le rendono costanti.

Tutte le funzioni non costanti dovrebbero impostare il flag di scrittura.

Aggiungerei anche la funzione Save( int fileHandle ). Questa funzione dovrebbe scrivere la struttura e resettare il flag.

Potete fare una funzione statica per ottenere lo stato della bandiera.

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

Io eliminerei del tutto queste funzioni.

Rendere costanti tutte le funzioni che non cambiano la struttura.

Tutte le funzioni non costanti dovrebbero impostare il flag di scrittura.

Ti dico che ho problemi con i modificatori in generale.


SZY: nel frattempo cosa sta succedendo in generale nel web nella discussione sulla programmazione - qui c'era un articolo su const su hobber il mese scorso, il significato - questo const non è necessario, guarda il codice assembler non è diverso senza const - il compilatore porterà via tutto ((

 
Igor Makanu:

Ti dico che ho problemi con i modificatori in generale.

Ho cercato su Google e ho letto, qualcosa è andato di nuovo storto...

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

si aspettava di ottenerePrint("const") almeno una volta;
 
Igor Makanu:

Googlato, letto, qualcosa è andato di nuovo storto...

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

si aspettava di ottenerePrint("const") almeno una volta;
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);
 }
Questo è un sovraccarico per una classe costante.
 
Vladimir Simakov:
Questo è un sovraccarico per una classe costante.

Hmmm... giusto, ho passato quasi mezz'ora a leggere sia l'hub che i forum, ma non sono riuscito a capirci niente.

Grazie, ora ce l'ho

C'è ancora il sospetto di un tale esempio:

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


ha dato gli stessi valori, ma il punto è molto diverso? - Allora avete bisogno di nuovo dell'aiuto della sala.
 
In questo momento sono seduto a una lezione su OOP. Forse condividerò qualcosa di utile con voi )).
Posso scaricare la lezione attuale. Fin qui, naturalmente, le cose banali.
 
Nikolai Semko:
Sto assistendo a una conferenza su OOP in questo momento. (Forse condividerò quello che imparerò))
Posso scaricare la lezione attuale. Fin qui, naturalmente, le cose banali.

Beh, la tua lezione è molto probabilmente in gibberish, mentre qui si impara a malapena qualcosa in russo, hai girato su Internet per la terza volta... la situazione generale è cupa come qui sul forum, i veri programmatori - non più di 10 persone sulla risorsa, il resto sono smanettoni

Ok, la situazione generale si è chiarita con const, ho lavorato con il resto dei modificatori, quindi ho un sacco di teoria ... Ho bisogno di applicarlo, ma mi sento come uno studente )))

 
Igor Makanu:

Beh, la tua lezione è molto probabilmente in gibberish, mentre qui si impara a malapena qualcosa in russo, hai girato su Internet per la terza volta... la situazione generale è cupa come qui sul forum, i veri programmatori - non più di 10 persone sulla risorsa, il resto sono smanettoni

Ok, la situazione generale si è chiarita con const, ho lavorato con il resto dei modificatori, quindi ho un sacco di teoria ... Mi sento come uno studente ))).

Sì, anch'io ho una situazione simile. Imparare non è difficile, è più difficile riqualificarsi, rompere le vecchie abitudini. Non riesco ancora a prendere a calci molte cattive abitudini della programmazione procedurale.

 
Igor Makanu:

Vorrei un esempio, ti dico che non sono per niente bravo con i modificatori.


SZY: inoltre in generale l'orrore che sta succedendo nel web nella discussione sulla programmazione - qui c'era un articolo su const su hubra il mese scorso, il significato - sì non abbiamo bisogno di questo const, guarda il codice assembler non differisce che senza const - il compilatore rimuoverà tutto (((

Potete semplicemente dimenticare le costanti e la statica per ora. Anche sulle interfacce.

E quando tutto è pronto, allora guardate e segnate qualcosa come statica e qualcosa come costante. E potete dimenticare del tutto le interfacce.