Preguntas sobre POO en MQL5 - página 95

[Igor Makanu]

Maxim Kuznetsov:

la AG es más bien una "palabra de moda". ¿Cómo puede el código de Gray ayudar a la convergencia? Sólo en teoría...

también podrías barajar al azar

no digo nada, no me creo todo lo que se escribe en internet desde hace mucho tiempo, intento comprobarlo todo

aquí hay un código de conversión que funciona al código de Gray y viceversa

//+------------------------------------------------------------------+
uint IntToGrey(const uint value) // https://e-maxx.ru/algo/gray_code
  {  return(value ^ (value >> 1)); }
//+------------------------------------------------------------------+
uint GreyToInt(const uint value) // https://e-maxx.ru/algo/gray_code
  {
   uint n = 0;
   for(uint g = value; g != 0; g >>= 1)
     {
      n ^= g;
     }
   return(n);
  }
//+------------------------------------------------------------------+

[Dmitry Fedoseev]

¿Y cómo afectaría esto al algoritmo genético? El algoritmo genético no debe responder a los valores si es puramente genético. Si se utiliza algún promedio adicional o el descenso de gradiente, puede afectarlo. Pero en este caso es mejor resolver el problema de forma directa - filtrar el parámetro a través del array y barajar el array. El valor del parámetro optimizado de la ventana de propiedades es un índice del elemento del array, y el valor del array se utilizará en el propio Asesor Experto. Entonces se puede engañar al optimizador. Pero sólo si la convergencia se produce debido al promedio o al descenso de gradiente. Pero si se trata de un algoritmo genético puro, no puedo imaginar de qué servirá. ¿Qué sentido tiene? ¿De dónde salen las piernas?

[Igor Makanu]

hay este código:

class A
{
private:
   const int _a;
public:
   A(const int a): _a(a) { Print(_a); }
};
//+------------------------------------------------------------------+
class B
{
private:
   const A a;
public:
   B(const int b): a(b) {}
};
//+------------------------------------------------------------------+
void OnStart()
{
   B b(3);// 3
}
//+------------------------------------------------------------------+

todo está bien, pero necesito un array de objetos A, es decir, lo necesito así:

class B
{
private:
   const A a[2];
public:
   B(const int b): a[0](b),a[1](b) {}  //'[' - member(s) initialization expected
                                       // 'a' - explicit initializer for arrays not allowed
};

¿hay alguna forma de llamar a un constructor para un array de objetos sin usar punteros?

[Vladimir Simakov]

Igor Makanu:

hay este código:

todo está bien, pero necesito un array de objetos A, es decir, lo necesito así:

¿hay alguna forma de llamar a un constructor para un array de objetos sin usar punteros?

No. Sólo a través de muletas.

[Igor Makanu]

¿Es posible para este código:

//+------------------------------------------------------------------+
struct LIST;
struct MyStruct
{
   double            d_data;
   int               i_data;
   MyStruct() {}
   MyStruct(const int i_v, const double d_v): d_data(d_v), i_data(i_v) {}
   LIST              operator+(MyStruct &value)
   {
      LIST result;
      ArrayResize(result.arr, 2, 10);
      result.arr[0] = this;
      result.arr[1] = value;
      return(result);
   }
   MyStruct          operator*(const double mult)
   {
      MyStruct result = this;
      result.d_data *= mult;
      return(result);
   }
};
//+------------------------------------------------------------------+
struct LIST
{
   MyStruct          arr[];
   LIST              operator+(MyStruct &value)
   {
      int last = ArraySize(this.arr);
      ArrayResize(this.arr, last + 1, 10);
      this.arr[last] = value;
      return(this);
   }
};
//+------------------------------------------------------------------+
void OnStart()
{
   MyStruct a(1, 1.11), b(2, 2.22), c(3, 3.33);
   LIST x = a + b + c * 2;
   ArrayPrint(x.arr);
//    [d_data] [i_data]
//[0]  1.11000        1
//[1]  2.22000        2
//[2]  6.66000        3
}
//+------------------------------------------------------------------+

para que LIST haga una plantilla/plantilla ?

No funcionó la primera vez (((.

[Vladimir Simakov]

Igor Makanu:

¿Es posible para este código:

para que LIST haga una plantilla/plantilla ?

no funcionó la primera vez ((.

esto. eliminar

UPD: hmm... lo tienes todo resuelto))))

UPD: obtener el yum))))

//+------------------------------------------------------------------+
template<typename T>
struct LIST
{
   T          arr[];
   LIST<T>              operator+(T &value)
   {
      int last = ArraySize(arr);
      ArrayResize(arr, last + 1, 10);
      arr[last] = value;
      return(this);
   }
};
//+------------------------------------------------------------------+
struct MyStruct
{
   double            d_data;
   int               i_data;
   MyStruct() {}
   MyStruct(const int i_v, const double d_v): d_data(d_v), i_data(i_v) {}
   LIST<MyStruct>              operator+(MyStruct &value)
   {
      LIST<MyStruct> result;
      ArrayResize(result.arr, 2, 10);
      result.arr[0] = this;
      result.arr[1] = value;
      return(result);
   }
   MyStruct          operator*(const double mult)
   {
      MyStruct result = this;
      result.d_data *= mult;
      return(result);
   }
};
//+------------------------------------------------------------------+
void OnStart()
{
   MyStruct a(1, 1.11), b(2, 2.22), c(3, 3.33);
   LIST<MyStruct> x = a + b + c * 2;
   ArrayPrint(x.arr);
//    [d_data] [i_data]
//[0]  1.11000        1
//[1]  2.22000        2
//[2]  6.66000        3
}

[Igor Makanu]

Vladimir Simakov:

esto. eliminar

UPD: hmmm... lo tienes todo resuelto))))

UPD: coge el yum-yum))

Gracias. - ¡funciona!

el código es minimalista, funciona - quiero una matriz de estructuras, las listas no son siempre convenientes, todo funciona, está claro que las situaciones no estándar utilizando este código puede ser simulado, pero el código una docena de líneas

[Igor Makanu]

por qué este código no da un error de compilación al acceder al campo privado de otra persona:

class A
{
private:
   int _value;
public:
  void set(const int value)      { _value = value;    }
  int  get()                     { return(_value);    }
  void set(A &a, const int value){ a._value = value;  }
};

void OnStart()
{
  A x,y;
  x.set(10);
  y.set(20);
  Print("x = ",x.get());   // 10
  Print("y = ",y.get());   // 20
  y.set(x,777);
  Print("x = ",x.get());   // 777
  Print("y = ",y.get());   // 20
}
//+------------------------------------------------------------------+

[Andrei Trukhanovich]

es su propio campo privado

[Igor Makanu]

Andrei Trukhanovich:
este es su propio campo privado

Bien, ¡gracias!

Pero si una clase derivada en una clase padre cambia los campos privados de la misma manera, ¿es "legal"?

es decir, de manera similar:

class B: private A
{
        A a;
        void setA(A &obj, const int value) { a.set(obj,value); }
}
....
A x;
B y;
y.(x.55)