Preguntas sobre POO en MQL5 - página 36

Nuevo comentario
 
Igor Makanu:

Pues sí, ¡es una solución mejor! para que haya un método menos

Sólo debería haber un nuevo en OnStart.
 
Koldun Zloy:

1. No hay nada malo en llamar a esta función dos veces.

2. ¿No te molesta que los que están en contra de usar funciones estáticas no den el más mínimo argumento?

Es mejor que no veas vídeos de cualquiera, sino que leas libros.

Le deseo al autor de los videos https://youtu.be/lfdAwl3-X_c y https://youtu.be/zME4SOCHT0I muchas cosas buenas..... noqueado toda la semana, todo lo que me siento a hacer lo empiezo a pensar, no a hacer como antes .... ¡no se puede utilizar la estática, no es OOP!

Quiero terminar el código, no consigo entender la siguiente pregunta:

- Quiero guardar los campos de los objetos, lo bueno es que los campos se colocaron inmediatamente en las estructuras, y se pueden guardar con un solo clic a través de FileWriteStruct()

- hay N objetos de una clase, todos ellos heredados de una clase base

- porque he visto el video, esperaba que algún método me ayudara a no interrogar a cada objeto si necesitaba guardar el archivo.... En general, fiasco, se decidió no ser tonto y crear un método que asignará estáticamente una bandera para escribir en el archivo

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

Funciona según lo previsto

Y la pregunta en sí, qué pasará si lo escribes así:

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

lo que sucederá si lo escribes de esta manera:

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

he probado diferentes formas de modificar el script de prueba, no puedo ver ninguna diferencia, muéstrame los modificadores correctos para el puesto de arriba: (protegido / privado ) y llamar a M::x o simplemente 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:

probado diferentes maneras de modificar la secuencia de comandos de prueba, no veo ninguna diferencia, me muestran los modificadores correctos para el puesto de arriba: (protegido / privado ) y llamar a M::x o simplemente x

Dentro de los métodos de la clase se llama a x, en todos los demás lugares M::x. Si está protegido, entonces la referencia es posible sólo en los métodos de la clase en la que se define el campo, aquí la lógica es común.
 
Felices vacaciones, por cierto. Ha ocurrido otro byte.
 
Vladimir Simakov:
Dentro de los métodos de la clase se llama a x, en todos los demás lugares M::x, si está protegido, entonces el acceso es posible sólo en los métodos de la clase en la que se define el campo, aquí la lógica es común.

Correcto! Hice un ejemplo erróneo en mi sueño, por lo que obtuve 'M::main' - no puede acceder a una función miembro privada:

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;

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

tiene 'M::main' - no puede acceder a la función miembro privada tst.mq5 25 32

Si lo escribo

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

¡todo funciona según lo previsto!

 
Vladimir Simakov:
Felices vacaciones, por cierto. Ha pasado otro byte.

Gracias, ya está solucionado.

¡Felices fiestas!

 
Igor Makanu:

Le deseo al autor de los videos https://youtu.be/lfdAwl3-X_c y https://youtu.be/zME4SOCHT0I un montón de cosas buenas..... noqueado toda la semana, todo lo que me siento a hacer lo empiezo a pensar en lugar de hacer como antes .... ¡no se puede utilizar la estática, no es OOP!

Quiero terminar el código, tengo una pregunta:

- Quiero guardar los campos de los objetos, lo bueno es que los campos se colocaron inmediatamente en las estructuras, y se pueden guardar con un solo clic a través de FileWriteStruct()

- hay N objetos de una clase, todos ellos heredados de una clase base

- porque he visto el video, esperaba que algún método me ayudara a no interrogar a cada objeto si necesitaba guardar el archivo.... En general, fiasco, se decidió no ser tonto y crear un método que asignará estáticamente una bandera para escribir en el archivo

Funciona según lo previsto

Y la pregunta en sí, qué pasará si lo escribes así:

lo que sucede si lo escribes de esta manera:

¿De qué depende que un objeto deba guardarse en un archivo?

¿Esta bandera es común para todos los objetos?

 
Koldun Zloy:

¿De qué depende guardar el objeto en un archivo?

¿Es una característica común a todos los objetos?

Bueno, la cuestión es dialéctica, por supuesto, aquí

- Es mejor tener 10 estrategias y escribir 10 archivos con cambio de estado de TC (1 TC = 1 estructura)

- o es más lógico pasar un handle de la clase, donde hay una llamada (búsqueda) de estrategias por tick, por lo que todas escriben en un archivo

Creo que la segunda variante es más lógica


resulta que después del inicio de todos los TCs hay que escribir 10 estructuras una vez - el estado ha cambiado

entonces en orden aleatorio que necesitan para escribir cuando sea necesario ( activación de SL o TP) - aquí también es más rápido para abrir el archivo y escribir 10 estructuras de una sola vez, las estrategias no son pipswise, no cada segundo, de un minuto a una hora en cada TS


Hasta ahora he implementado una descripción de una variable estática y el acceso a ella a través de un get - set, set protected, get public - también se restablece a false la variable estática después de la llamada

 
Igor Makanu:

Bueno, la cuestión es dialéctica, por supuesto, aquí

- Tiene o 10 estrategias y escribe 10 archivos con cambio de estado de TC (1 TC = 1 estructura)

- o es más lógico pasar una manija de la clase, donde hay una llamada ( búsqueda) de estrategias en un tick, por lo que escriben todos en un archivo

Creo que la segunda variante es más lógica


resulta que después del inicio de todos los TCs hay que escribir 10 estructuras una vez - el estado ha cambiado

entonces en orden aleatorio que necesitan para escribir cuando sea necesario ( activación de SL o TP) - aquí también es más rápido para abrir el archivo y escribir 10 estructuras de una sola vez, las estrategias no son pipswise, no cada segundo, de un minuto a una hora en cada TS


Por ahora he implementado mediante la descripción de una variable estática el acceso a la misma a través de un Get, Set Protegido, Get público - también se restablece a falso la variable estática después de que se ha llamado

Todo esto está claro. No está claro por quéSetSaveRequired() yGetSaveRequired() no son estáticas pero escriben en una variable estática.

1...293031323334353637383940414243...96
Nuevo comentario