Questions sur la POO dans MQL5 - page 91

Nouveau commentaire
 
Dmitry Fedoseev:

Pourquoi ça ne marcherait pas tout d'un coup ? Trois énumérations, dont aucune ne dépasse 10. Arithmétique de deuxième année de collège.

3 énumérations plus 2 int , vous avez besoin de 4 bytes = int

int j'ai besoin dans la gamme +1000 -... +1000, pips, c'est juste 2^10.

les int sont à considérer, le pas de 1 pips n'est pas important, 2.5-...9 pips est aussi possible, c'est-à-dire que la discrétisation n'est pas très critique

 
Igor Makanu:

3 énumérations plus 2 int , besoin dans 4 bytes

int j'ai besoin dans la gamme +1000 -... +1000, pips, c'est juste 2^10.

les int sont encore à considérer, les incréments de 1 pip ne sont pas importants, vous pouvez avoir 2.5-...9 pps, c'est-à-dire que la discrétisation n'est pas si critique

Il y a plus qu'assez d'espace. INT_MAX=2147483647.

Nous pourrions opter pour les dizaines au lieu de la franchise et de la brutalité, et faire 8*8*4 avec parcimonie. Il suffit d'y réfléchir)))) Mais ce n'est pas nécessaire, tout s'emboîte de toute façon.

Et pour vérifier - pourquoi ne pas commencer le cycle jusqu'à INT_MAX - le matériel le vérifiera, et non pas chercher dans le fichier avec les résultats par lui-même.

 
Dmitry Fedoseev:

Plus qu'assez d'espace. INT_MAX=2147483647.

Vous pouvez également pas stupidement et droit - dizaines d'occuper, et économiquement, de faire dans un pincement - 8*8*4. Il n'y a que vous qui devez penser))) Mais ce n'est pas nécessaire, tout s'emboîte de toute façon.

Et pour vérifier - pourquoi ne pas faire un cycle jusqu'à INT_MAX - cela sera vérifié par le matériel, nous n'aurons pas besoin de regarder le fichier de résultat par nous-mêmes.

Ça ne me dérange pas... J'ai besoin du code à évaluer et la méthodologie est plus importante que la façon de convertir.

 
Igor Makanu:

Ça ne me dérange pas... J'ai besoin du code à évaluer, et la méthodologie de test est plus importante que la façon de convertir le code.

Amorçage par bit, non ? C'est comme si l'on convertissait un nombre en une chaîne de caractères avec des valeurs de type bit. Un pour les nombres entiers et un pour les points et les contrôles. C'est juste pour le débogage.

 
Alexandr Andreev:

La réécriture par bit, non ? Quelque chose comme l'enchaînement d'un nombre avec des valeurs de type bit. Un pour les nombres entiers et un pour les points et les contrôles. C'est juste pour le débogage.

Oui, c'est clair, mais comment automatiser la vérification ?

le problème, pas dans mon exemple, mais dans le fait que j'ai encore besoin d'emballer dans 3 int d'autres données, je ne veux pas passer trop de temps sur la vérification de chaque paquet


ZS : l'idée est brillante, mais pas les valeurs bitwise, mais hex - à partir de printf() vous pouvez obtenir, ou plutôt de stringformat()

 
Igor Makanu:

Oui, c'est clair, mais comment automatiser la vérification ?

Le problème, pas dans mon exemple, mais dans le fait que j'ai encore besoin d'emballer dans 3 int d'autres données, je ne veux pas passer beaucoup de temps sur la vérification de chaque paquet.


HH : bonne idée, mais pas les valeurs bitwise, mais hex - nous pouvons les obtenir à partir de printf() ou plutôt de stringformat()

)) ne peut pas comprendre ce qui est nécessaire

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

Voulons-nous automatiser une compensation ou quoi ?

Quel est ce chèque ?

Et nous pouvons toujours vérifier la source et les valeurs converties.

 
Igor Makanu:

Ça ne me dérange pas... Vous avez besoin du code à évaluer, et la méthodologie de vérification est plus importante que la façon de convertir les données.

Si la méthodologie de conversion est claire et compréhensible, vous n'avez pas besoin de beaucoup de vérifications.

  
...
   static int        sign;
   static int        _sign;
   static int        mean;
public:
...
   int               Get() const;
   static void       Print(int val);
private:
   int               GetInt12(int val) const {return ((val&sign)>>20)|(val&mean);}
   static int        GetInt(int val) {return (val&_sign)<<20|(val&mean);}
  };
...
//------------------------------------------------------------------------
int CSetting::Get() const{
   return t<<29|d<<26|v<<24|GetInt12(param1)<<12|GetInt12(param2);
}
//------------------------------------------------------------------------
void CSetting::Print(int val){
   PrintFormat("%s, %s, %s, %i, %i",EnumToString(T(val>>29)),EnumToString(D(val>>26)),EnumToString(V(val>>24)),GetInt(val>>12),GetInt(val));
}
int CSetting::sign=1<<31;
int CSetting::_sign=1<<11;
int CSetting::mean=0xFFFFFFFF>>21;

void OnStart(void)
  {
   CSetting test(Input_p1,Input_p2,Input_T,Input_D,Input_V);
   int res=test.Get();
   Print ("int=",res);
   CSetting::Print(res);
 }
 
Vladimir Simakov:

Il est évident qu'il y aura plus de variables. Pour moi, il est préférable d'utiliser la copie de structures par octet (le processus ne nécessite probablement pas une forte optimisation de la vitesse, mais la commodité sera primordiale).

  
void OnStart()
  {

   int a=9;
   int b=8;
   int c=7;
   int d=12345;

   int v=pack(a,b,c,d);
   
   int a2,b2,c2,d2;
   unpack(v,a2,b2,c2,d2);
   
   Alert(a2," ",b2," ",c2," ",d2);

}

void unpack(int val,int & a,int & b,int & c,int & d){
   d=val/1000;
   val%=1000;
   c=val/100;
   val%=100;   
   b=val/10;
   a=val%10;
}

int pack(int a,int b,int c,int d){
   return(a+b*10+c*100+d*1000);
}

De moins en moins cher

1...84858687888990919293949596
Nouveau commentaire