Questions sur la POO dans MQL5 - page 95

Nouveau commentaire
 
Maxim Kuznetsov:

l'AG est plus un mot à la mode. Comment le code de Gray peut-il aider à la convergence ? Juste en théorie...

vous pourriez tout aussi bien mélanger aléatoirement

je ne dis rien, je ne crois pas tout ce qui est écrit sur internet depuis longtemps, j'essaie de tout vérifier

Voici un code de conversion fonctionnel vers le code de Gray et inversement.

//+------------------------------------------------------------------+
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);
  }
//+------------------------------------------------------------------+
 
Et comment cela affecterait-il l'algorithme génétique? L'algorithme génétique ne devrait pas réagir aux valeurs s'il est purement génétique. Si une moyenne supplémentaire ou une descente de gradient est utilisée, cela peut l'affecter. Mais dans ce cas, il est préférable de résoudre le problème de manière directe - en filtrant le paramètre à travers le tableau et en mélangeant le tableau. La valeur du paramètre optimisé dans la fenêtre des propriétés est un index de l'élément du tableau, et la valeur du tableau sera utilisée dans le conseiller expert lui-même. Alors l'optimiseur peut être trompé. Mais seulement si la convergence se produit grâce au calcul de la moyenne ou à la descente du gradient. Mais s'il s'agit d'un pur algorithme génétique, je ne peux pas imaginer à quoi il servira. Quel est l'intérêt ? D'où viennent les jambes ?
 

il y a ce code :

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
}
//+------------------------------------------------------------------+

tout est OK, mais j'ai besoin d'un tableau d'objets A, c'est-à-dire que j'en ai besoin comme ceci :

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

Existe-t-il un moyen d'appeler un constructeur pour un tableau d'objets sans utiliser de pointeurs ?

 
Igor Makanu:

il y a ce code :

tout est OK, mais j'ai besoin d'un tableau d'objets A, c'est-à-dire que j'en ai besoin comme ceci :

Existe-t-il un moyen d'appeler un constructeur pour un tableau d'objets sans utiliser de pointeurs ?

Non. Seulement avec des béquilles.
 

Est-il possible pour ce code :

//+------------------------------------------------------------------+
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
}
//+------------------------------------------------------------------+

pour LIST de faire un modèle / gabarit ?

Ça n'a pas marché la première fois (((.

 
Igor Makanu:

Est-il possible pour ce code :

pour LIST de faire un modèle / gabarit ?

cela n'a pas fonctionné la première fois ((.

Ceci.

UPD : hmm... vous avez tout compris))))

UPD : obtenir le 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
}
 
Vladimir Simakov:

Ceci.

UPD : hmmm... vous avez tout compris))))

UPD : attrape le miam-miam))))

Merci ! - ça marche !

le code est minimaliste, il fonctionne - je veux un tableau de structures, les listes ne sont pas toujours pratiques, tout fonctionne, il est clair que les situations non standard utilisant ce code peuvent être simulées, mais le code d'une douzaine de lignes

 

pourquoi ce code ne donne pas d'erreur de compilation en accédant au champ privé de quelqu'un d'autre:

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
}
//+------------------------------------------------------------------+
 
est son propre champ privé
 
Andrei Trukhanovich:
il s'agit de son propre champ privé

OK, merci !

Mais si une classe dérivée d'une classe mère modifie les champs privés de la même manière, est-ce "légal" ?

c'est-à-dire d'une manière similaire :

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