Domande su OOP in MQL5 - pagina 36

Nuovo commento
 
Igor Makanu:

Beh sì, questa è una soluzione migliore! in modo che ci sia un metodo in meno

Ci dovrebbe essere solo un nuovo in OnStart.
 
Koldun Zloy:

1. Non c'è niente di male nel chiamare questa funzione due volte.

2. Non vi dispiace che coloro che sono contro l'uso delle funzioni statiche non diano il minimo argomento?

È meglio non guardare video di chiunque, ma leggere libri.

Auguro all'autore dei video https://youtu.be/lfdAwl3-X_c e https://youtu.be/zME4SOCHT0I tante buone cose..... buttato giù tutta la settimana, ogni cosa che mi siedo a fare inizio a pensare, non a fare come prima .... non puoi usare la statica, non è OOP!

Voglio finire il codice, ho una domanda:

- Voglio salvare i campi degli oggetti, bene, i campi sono stati immediatamente inseriti nelle strutture, ed è possibile salvarli con un solo clic tramite FileWriteStruct()

- ci sono N oggetti di una classe, tutti ereditati da una classe base

- poiché ho guardato il video, speravo che qualche metodo mi aiutasse a non interrogare ogni oggetto se aveva bisogno di salvare il file.... In generale, fiasco, si è deciso di non essere sciocchi e creare un metodo che assegnerà staticamente un flag per scrivere sul file

class CStrategy: public IStrategy
{
protected:
static bool       f_save_required;
void              SetSaveRequired()        { CStrategy::f_save_required = true;                    }
public:
bool              GetSaveRequired()        { return(CStrategy::f_save_required);                   }

Funziona come previsto

E la domanda stessa, cosa succederà se la scrivi in questo modo:

class CStrategy: public IStrategy
{
private:
static bool       f_save_required;
protected:
void              SetSaveRequired()        { CStrategy::f_save_required = true;                    }
public:
bool              GetSaveRequired()        { return(CStrategy::f_save_required);                   }

cosa succederà se lo scrivi in questo modo:

class CStrategy: public IStrategy
{
private:
static bool       f_save_required;
protected:
void              SetSaveRequired()        { f_save_required = true;                    }
public:
bool              GetSaveRequired()        { return(f_save_required);                   }
 

provato diversi modi per modificare lo script di prova, non riesco a vedere alcuna differenza, mostrami i modificatori corretti per il post sopra: (protetto / privato) e chiama M::x o solo x

//+------------------------------------------------------------------+
interface I
{  bool main();

};
//+------------------------------------------------------------------+
class M:public I
{
protected:
static int        x;
bool              main()   { x++;  Print(__FUNCTION__," = ",x); return(x>0); }
public:
                     M()      { Print(__FUNCTION__);}
                    ~M()      { Print(__FUNCTION__);}
};
//+------------------------------------------------------------------+

static int M::x=0;
//+------------------------------------------------------------------+
class A:public M
{
public:
                     A()      { Print(__FUNCTION__);}
                    ~A()      { Print(__FUNCTION__);} };
//+------------------------------------------------------------------+
class B:public M
{
public:
                     B()      { Print(__FUNCTION__);}
                    ~B()      { Print(__FUNCTION__);} };
//+------------------------------------------------------------------+
class C:public M
{
public:
                     C()      { Print(__FUNCTION__);}
                    ~C()      { Print(__FUNCTION__);} };
//+------------------------------------------------------------------+

void OnStart()
{  I *a = new A;
   I *b = new B;
   I *c = new C;
   I *m = new M;

   a.main();
   b.main();
   c.main();
   m.main();


   delete a;
   delete b;
   delete c;
   delete m;

}
//+------------------------------------------------------------------+
 
Igor Makanu:

provato diversi modi per modificare lo script di prova, non vedo alcuna differenza, mostrami i modificatori corretti per il post sopra: (protetto / privato) e chiama M::x o solo x

All'interno dei metodi di classe si chiama x, in tutti gli altri posti M::x. Se protetto, allora il riferimento è possibile solo nei metodi della classe in cui il campo è definito, qui la logica è comune.
 
A proposito, buone vacanze. È successo un altro byte.
 
Vladimir Simakov:
All'interno dei metodi di classe si chiama x, in tutti gli altri posti M::x, se protetto, allora l'accesso è possibile solo nei metodi della classe in cui il campo è definito, qui la logica è comune.

Giusto! Ho fatto un esempio sbagliato nel mio sonno, quindi ho ottenuto 'M::main' - non può accedere alla funzione membro privata:

class M
{
private:
   static int        x;
   bool              main()   { x++;  Print(__FUNCTION__," = ",x); return(x>0); }
public:
                     M()      { Print(__FUNCTION__);}
                    ~M()      { Print(__FUNCTION__);} };
//+------------------------------------------------------------------+

static int M::x=0;
//+------------------------------------------------------------------+
class A:public M
{
public:
                     A()      { Print(__FUNCTION__);}
                    ~A()      { Print(__FUNCTION__);}
   void                inc()     {main();} };
//+------------------------------------------------------------------+
class B:public M
{
public:
                     B()      { Print(__FUNCTION__);}
                    ~B()      { Print(__FUNCTION__);}
   void                inc()     {main();} };
//+------------------------------------------------------------------+
class C:public M
{
public:
                     C()      { Print(__FUNCTION__);}
                    ~C()      { Print(__FUNCTION__);}
   void                inc()     {main();} };
//+------------------------------------------------------------------+
void OnStart()
{  A *a = new A;
   B *b = new B;
   C *c = new C;
   M *m = new M;

   a.inc();



   delete a;
   delete b;
   delete c;
   delete m;

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

got 'M::main' - cannot access private member function tst.mq5 25 32

Se lo scrivo

protected:   
   bool              main()   { x++;  Print(__FUNCTION__," = ",x); return(x>0); }

tutto funziona come previsto!

 
Vladimir Simakov:
A proposito, buone vacanze. È successo un altro byte.

Grazie, è risolto!

Buone Feste!

 
Igor Makanu:

Auguro all'autore dei video https://youtu.be/lfdAwl3-X_c e https://youtu.be/zME4SOCHT0I un sacco di buone cose ..... buttato giù tutta la settimana, tutto quello che mi siedo a fare comincio a pensare piuttosto che fare come prima .... non puoi usare la statica, non è OOP!

Voglio finire il codice, ho una domanda:

- Voglio salvare i campi degli oggetti, bene, i campi sono stati immediatamente inseriti nelle strutture, ed è possibile salvarli con un solo clic tramite FileWriteStruct()

- ci sono N oggetti di una classe, tutti ereditati da una classe base

- poiché ho guardato il video, speravo che qualche metodo mi aiutasse a non interrogare ogni oggetto se aveva bisogno di salvare il file.... In generale, fiasco, si è deciso di non essere sciocchi e creare un metodo che assegnerà staticamente un flag per scrivere sul file

Funziona come previsto

E la domanda stessa, cosa succederà se la scrivi in questo modo:

cosa succede se si scrive in questo modo:

Da cosa dipende se un oggetto deve essere salvato in un file?

Questa bandiera è comune a tutti gli oggetti?

 
Koldun Zloy:

Da cosa dipende il salvataggio dell'oggetto in un file?

È una caratteristica comune a tutti gli oggetti?

Beh, la questione è dialettica, naturalmente, qui

- È meglio avere 10 strategie e scrivere 10 file con cambio di stato di TC (1 TC = 1 struttura)

- o è più logico passare un handle dalla classe, dove c'è una chiamata (ricerca) di strategie per tick, quindi scrivono tutte in un file

Penso che la seconda variante sia più logica


si scopre che dopo l'inizio di tutti i TC è necessario scrivere 10 strutture una volta - lo stato è cambiato

poi in ordine casuale hanno bisogno di scrivere quando necessario (innesco di SL o TP) - qui è anche più veloce per aprire il file e scrivere 10 strutture in una sola volta, le strategie non sono pipswise, non ogni secondo, da un minuto a un'ora in ogni TS


Finora ho implementato una descrizione di una variabile statica e l'accesso ad essa attraverso un get - set, set protected, get public - inoltre resetta a false la variabile statica dopo la chiamata

 
Igor Makanu:

Beh, la questione è dialettica, naturalmente, qui

- Avete o 10 strategie e scrivete 10 file con cambio di stato di TC (1 TC = 1 struttura)

- o è più logico passare un handle dalla classe, dove c'è una chiamata (ricerca) di strategie su un tick, quindi scrivono tutto in un file

Penso che la seconda variante sia più logica


si scopre che dopo l'inizio di tutti i TC è necessario scrivere 10 strutture una volta - lo stato è cambiato

poi in ordine casuale devono scrivere quando necessario (innesco SL o TP) - qui è anche più veloce aprire il file e scrivere 10 strutture in una sola volta, le strategie non sono pipswise, non ogni secondo, da un minuto a un'ora in ogni TS


Per ora ho implementato attraverso la descrizione di una variabile statica l'accesso ad essa tramite get - set, set protected, get public - inoltre resetta la variabile statica a false dopo che è stata chiamata

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

1...293031323334353637383940414243...96
Nuovo commento
Motivazione: