Perguntas sobre OOP em MQL5 - página 91

Novo comentário
 
Dmitry Fedoseev:

Por que não funcionaria de repente? Três enumerações, nenhuma delas mais do que 10. Aritmética da segunda série do ensino médio.

3 enumerações mais 2 int , você precisa de 4 bytes = int

na faixa de +1000 -... +1000 , pips, isso é apenas 2^10

vale a pena considerar, o passo 1 pips não é importante, 2,5-...9 pips também é possível, ou seja, a discrição não é muito crítica

 
Igor Makanu:

3 enumerações mais 2 int , necessidade em 4 bytes

na faixa de +1000 -... +1000 , pips, isso é apenas 2^10

vale a pena considerar ainda, 1 pip incrementos não são importantes, você pode ter 2,5-....9 pps, ou seja, a discrição não é tão crítica

Há espaço mais do que suficiente. INT_MAX=2147483647.

Poderíamos fazer dezenas em vez de simples e sem rodeios, e fazer 8*8*4 com parcimônia. Você só tem que pensar nisso)))) Mas não há necessidade, tudo se encaixa de qualquer maneira.

E para verificar - por que não iniciar o ciclo até INT_MAX - o hardware irá verificá-lo, não para olhar o arquivo com resultados por si só.

 
Dmitry Fedoseev:

Espaço mais do que suficiente. INT_MAX=2147483647.

Você também não pode estupidamente e diretamente - dezenas para ocupar, e economicamente, para fazer em uma pitada - 8*8*4. Só você precisa pensar)))) Mas não há necessidade, tudo se encaixa de qualquer maneira.

E para verificar - por que não fazer o ciclo até INT_MAX - ele será verificado por hardware, não precisaremos olhar o arquivo de resultados por nós mesmos.

Eu não me importo... Eu preciso do código para avaliar e a metodologia é mais importante do que como converter

 
Igor Makanu:

Eu não me importo... Eu preciso do código para avaliar, e a metodologia de teste é mais importante do que como converter

Um pouco de priming, não? É como converter um número em um fio com valores bitwise. Um para números inteiros e outro para pontos e verificação. Isso é apenas para fins de depuração.

 
Alexandr Andreev:

Pouco escrito, não? Algo parecido com a encadernação de um número com valores bitwise. Um para números inteiros e outro para pontos e verificação. Isso é apenas para fins de depuração.

Sim, isso é claro, mas como você automatiza a verificação?

não no meu exemplo, mas no fato de que ainda preciso embalar 3 int's de outros dados, não quero gastar muito tempo na verificação de cada embalagem


ZS: a idéia é brilhante, mas não valores bitwise, mas hexadecimais - a partir de printf() você pode obter, ou melhor, a partir de stringformat()

 
Igor Makanu:

Sim, está tudo claro, mas como automatizar a verificação?

O problema, não no meu exemplo, mas no fato de que ainda preciso embalar em 3 int's de outros dados, não quero gastar muito tempo para verificar cada embalagem


HH: boa idéia, mas não valores bitwise, mas hexadecimais - podemos obtê-los a partir de printf() ou de stringformat()

)) não consegue descobrir o que é necessário

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

Queremos automatizar uma compensação ou não?

O que é este cheque?

E podemos sempre apenas verificar a fonte e os valores convertidos.

 
Igor Makanu:

Eu não me importo... Você precisa do código para avaliar, e a metodologia de verificação é mais importante do que a forma de conversão

Se a metodologia de conversão é clara e compreensível, então não há muita necessidade de verificação.

  
...
   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:

Bem, é óbvio que haverá mais variáveis para mim, é melhor usar apenas a cópia byte de estruturas (provavelmente o processo não requer uma forte otimização de velocidade, mas a conveniência será um prêmio).

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

Barato e barato

1...84858687888990919293949596
Novo comentário