Preguntas sobre POO en MQL5 - página 90

Nuevo comentario
 
Igor Makanu:

si en mi ejemplo:

copiar los valores de asc y bid en el método onTick() y utilizar _Ask, _Bid (comercio virtual) en el resto de los métodos

¿será como trabajar con variables globales?

ZS: como opción, puedo por supuesto pasar por referencia &tick a todos los métodos, pero de nuevo se pregunta qué es más eficiente

Si este tema sigue siendo relevante, me gustaría señalar que la opción de mantener los campos es tanto menos eficiente como menos correcta conceptualmente. En principio, los dos conceptos casi siempre se correlacionan.
El código limpio (sin efectos secundarios) siempre está mejor optimizado por el compilador y es más fácil de entender.
Si su objeto está destinado a cambiar su estado bajo la influencia de los datos de entrada, no debería almacenar esos datos de entrada (excepto para fines de almacenamiento en caché).
Hay que separar las moscas de las chuletas.

 

Una vez se hizo una pregunta sobre dos formas de inicializar variables en una clase. Este:

class CA{
   protected:
      int val;
   public:
      CA(){
         val=0;
      }      
};

Y esta otra:

class CA{
   protected:
      int val;
   public:
      CA():val(0){
      }      
};

Pregunté cuál es la ventaja de la segunda forma y me dijeron que se pueden inicializar miembros estáticos con ella. Pero los miembros estáticos no se inicializan de esa manera.

Así que la pregunta es la misma: ¿cuál es la diferencia en principio y cuál es la ventaja de la segunda vía?

[Eliminado]  

Cita

Хочется закончить свою песнь важными словами. Любые описанные механизмы, принципы и паттерны, как и ООП в целом не стоит применять там, где это бессмысленно или может навредить. Это ведет к появлению статей со странными заголовками типа «Наследование — причина преждевременного старения» или «Синглтон может приводить к онкологическим заболеваниям».
 
Dmitry Fedoseev:

Una vez se hizo una pregunta sobre dos formas de inicializar variables en una clase. Aquí hay uno como este:

https://www.mql5.com/ru/forum/85652/page45#comment_15975127

Dmitry Fedoseev:

Pregunté cuál es la ventaja de la segunda forma y me dijeron que los miembros estáticos pueden ser inicializados por ella. Pero los miembros estáticos no se inicializan de esa manera.

Son campos constantes , no estáticos.

class CA
{
protected:
   const int         val;
   static int        static_val;
public:
                     CA(): val(0) { }
};
static int CA::static_val = 12345;
Dmitry Fedoseev:

Así que la pregunta sigue siendo la misma: ¿cuál es la diferencia de principio y cuál es la ventaja de la segunda vía?

Si descartamos la afirmación "se considera de mala educación", entonces lo que sea más conveniente, es lo que usaremos, imho.

 
Sí, así es, constante, confuso)
 

Voy a empezar el tema de nuevo, he borrado el post anterior, creí que lo había resuelto por mi cuenta....


aquí está el código:

class CSetting  
{
public:
   enum T            {T1, T2, T3, T4, T5, T6, T7, T8};
   enum D            {D1, D2, D3, D4, D5, D6, D7, D8};
   enum V            {V1, V2, V3, v4};
private:
   int               param1, param2;
   T                 t;
   D                 d;
   V                 v;
public:
                     CSetting(const int in_param1,const int in_param2,const T in_t,const D in_d,const V in_v);
  };
//+------------------------------------------------------------------+
CSetting::CSetting(const int in_param1,const int in_param2,const T in_t,const D in_d,const V in_v)
   : param1(in_param1),
     param2(in_param2),
     t(in_t),
     d(in_d),
     v(in_v)
  {}

//--- input parameters
input int              Input_p1 = 1;   // p1 = -1000 ... +1000
input int              Input_p2 = 2;   // p2 = -1000 ... +1000
input CSetting::T      Input_T = CSetting::T::T1;
input CSetting::D      Input_D = CSetting::D::D1;
input CSetting::V      Input_V = CSetting::V::V1;

Quiero que 3 enums y 2 ints de la sección privat de CSetting se llenen con un int en el que poco a poco voy a almacenar estos datos, esbozado el código:

class CSetting
  {
public:
   enum T            {T1, T2, T3, T4, T5, T6, T7, T8};
   enum D            {D1, D2, D3, D4, D5, D6, D7, D8};
   enum V            {V1, V2, V3, v4};
private:
   int               param1, param2;
   T                 t;
   D                 d;
   V                 v;
public:
                     CSetting(const uint data);
  };
//+------------------------------------------------------------------+
CSetting::CSetting(const uint data)
{
   v = (V)(data & 0x3);
   d = (D)((data >> 2) & 0x7);
   t = (T)((data >> 5) & 0x7);
   uint tmp = ((data >> 8) & 0xFFF);
   param2 = (tmp & 0x800) == 0x800 ? -(int)(tmp & 0x7FF) : (int)(tmp & 0x7FF);
   tmp = data >> 20;
   param1 = (tmp & 0x800) == 0x800 ? -(int)(tmp & 0x7FF) : (int)(tmp & 0x7FF);
}
//+------------------------------------------------------------------+
//--- input parameters
input int DATA         = 0xFFFFFFFF;

en teoría, debería funcionar, tomo los 2 + 3 +3 bits inferiores de los datos para el enum , y los 24 bits restantes del int para rellenar param1 y param2, manteniendo el 12º bit como el carácter del número


¿Cómo puedo comprobar si hay un error? )))

o agradecería las ideas de alguien más sobre cómo guardar estos datos en int

 
Alternativa: t+d*10+v*100
 
Igor Makanu:

¿cómo se comprueba si hay errores? )))

La forma habitual: empaquetarlo, desempaquetarlo, comprobar si es idéntico. Preferiblemente, comprobar todos los casos límite.
 
Dmitry Fedoseev:
o t+d*10+v*100

esto no funcionará,

hay que desplazar bit a bit o multiplicar/dividir por 2, lo que equivale a desplazar

TheXpert:
bien, como siempre - empaquetarlo, desempaquetarlo, comprobar la identidad. preferiblemente comprobar todos los casos límite.

Así que, sí... lógicamente

pero no tenía previsto hacer el empaquetado - estoy disminuyendo el número de variables de entrada para el optimizador y necesito muchas pasadas de AG encima de ellas, para que el AG no converja rápidamente


Ya se han comprobado los casos límite, pero por experiencia.... ¡¡¡los bichos son tan astutos!!! )))

HH: Por supuesto, puedo restablecer el bucle de 0...MAX_UINT en un archivo y mirarlo visualmente, pero no es la mejor opción, imho.

 
Igor Makanu:

no funcionará,

...

¿Por qué no iba a funcionar? Tres enumeraciones, ninguna de ellas superior a 10. Aritmética de segundo grado de primaria.

1...8384858687888990919293949596
Nuevo comentario