Perguntas sobre OOP em MQL5 - página 93

Novo comentário
 
Igor Makanu:

outra pergunta... Existe alguma forma de se conseguir um int 12 bit via união? não importa como ))))

SZY: 9-15 bit int idealmente, assinar para alocar não é um problema, ou seja, é possível int sem assinatura (em últimas construções de MQL aprendidoint sem assinatura, é possível em vez de uint to use )

Não entendo... socorro!)))

Descobri que posso alocar algumas partes necessárias desta maneira:

//+------------------------------------------------------------------+
uint ConvertUintToXBits(const uint value, const int pos, const int cnt_bits)
{
   uint mask = (0xFFFFFFFF >> (sizeof(uint) - cnt_bits)) << pos;  // получили битовую маску
   uint result = value & mask;                                    // выделили биты числа
   return(result >> pos);                                         // сдвинули чтобы привести к 32-битам
}
//+------------------------------------------------------------------+

onde a parte mais significativa seria agora determinar o sinal do número. não sei, ou seja, idealmente deveria ser uma função

int ConvertUintToXBits(const uint value, const int pos, const int cnt_bits)

O ideal seria que fosse um modelo para utilizar tais estruturas:

struct Int12
{
private:
   const int bits;
public:
   Int12(const uint IntValue): bits(12) {ConvertUintToXBits.......}
   int value;
};
 
Igor Makanu:

Então novamente não entendo...socorro! socorro!)))

Descobri que posso alocar alguns dos pedaços que preciso:

onde o bit mais alto seria agora determinar o sinal do número. não sei, ou seja, idealmente deveria ser uma função

O ideal seria que fosse um modelo para utilizar tais estruturas:

Veja. A máscara é a parte significativa do número, ou seja, para int, você tem que mudar um pouco mais, já que o bit alto que você tem significa o sinal. <<pos é uma bagunça. Como no seu caso, você vai pegar pedaços altos de int por esta máscara, enquanto você precisa de pedaços baixos)))))).

Para inteiros assinados, você deve tomar uma parte significativa separadamente, pegar separadamente o bit alto (sinal), depois mudar o bit alto para a posição necessária e usar bitwise OR para combiná-los. Exemplo para int-> 4 bits

int mean4=0xFFFFFFFFFF>>29

sinal int16=1<<31

int sign4=1<3

Agora em->int4 observe suas mãos:

1. temos int val

2. int sign=(val&sign16)>>28.

Aqui pegamos o sinal de nosso número e o deslocamos para a posição correta (o bit mais significativo em int4)

3. mean3val=val&mean4

Aqui temos os três pedaços menos significativos (parte significativa) através de uma máscara, o resto é recortado.

4. int out=sign|mean3val

E aqui combinamos o sinal com a parte significativa. Agora temos 4 bits de baixa ordem, nos quais o bit 4 é o sinal, e os bits 1 a 3 são a parte significativa, todos os bits acima de 4 têm um valor de 0. O intervalo de valores é -8...7 E sim, se 8 for alimentado, não haverá 7 e será 0, pois tudo será cortado.

 

É mais fácil mudar pelo número certo de bits e usar 1 para a máscara. Pelo menos é mais óbvio.

Definição do sinal: (a>>31)&1 - se 1, então menos, se 0, então mais.

 

Posso fazer partes significativas da int com uma solução "head-on", mas não posso fazer uma solução universal... Eu não posso! (((

É altamente provável que eu não tenha explicado como e para onde quero ir.

há 4 bytes int / uint, e há meu conjunto de dados, que eu quero desempacotar no otimizador

vamos assumir que consegui empacotar:

0-8 9-16 17-24 25-32
int_11 int_9 int_12

que tipos eu preciso int_XXX, ainda não estimei

mas eu quero ter usabilidade na forma deste código

input int param1 = 0xFFFFFFF;
int MyParam_1 = ConVertUintToIntXXX((uint)param1, 0, 11);
int MyParam_2 = ConVertUintToIntXXX((uint)param1, 12, 9);
int MyParam_3 = ConVertUintToIntXXX((uint)param1, 21,12);
 

Ninguém ainda não encontrou meu erro? ))))

Dica: uint todas as máscaras devem ser))))

 
Igor Makanu:

Posso fazer partes significativas da int com uma solução "head-on", mas não posso fazer uma solução universal... Eu não posso! (((

É altamente provável que eu não tenha explicado como e para onde quero ir.

há 4 bytes int / uint, e há meu conjunto de dados, que eu quero desempacotar no otimizador

vamos assumir que consegui embalá-lo desta maneira:

0-8 9-16 17-24 25-32
int_11 int_9 int_12

que tipos eu preciso int_XXX, ainda não estimei

mas eu quero ter uma usabilidade na forma do seguinte código

int add(int o,int l,int v,int r){
   int m=(int)MathPow(2,l)-1;
   r=~r;   
   r=r|(m<<o);
   r=~r;
   r=r|(v<<o);
   return(r);
}

int extract(int o,int l,int r){
   int m=(int)MathPow(2,l)-1;
   return((r>>o)&m);
}

o - travessão (bits), l - comprimento (número de bits), valor a adicionar, r - onde adicionar

Mas ainda não o testei.

 
Dmitry Fedoseev:

Como você não está sobrepondo-se a uma função virtual, você está usando sobrecarga.


Há claramente algo errado aqui

 
Alexandr Andreev:

Obviamente há algo de errado aqui.

Faça do método um modelo e acesse-o

class A {
template<typename T>
void f( T ) {}
};
void OnStart()
{
        A а;
        а.f(0); //нормально
}
 
A100:

Faça do método um modelo e acesse-o

Isso é um laifhack!!!

ps: +1 maneira de escrever algo que simplesmente deixará de funcionar com a atualização quando eles ajustarem este pãozinho

 
Alexandr Andreev:

Isso é uma lacuna!!!

ps: +1 maneira de escrever algo que simplesmente deixará de funcionar com a atualização quando eles ajustarem este pãozinho

class A {
public:
void f( int ) {}
};
class B : public A {
public:
template<typename T>
void f( T ) { ffffffffffff(1); пишу что хочу %<>!!!<>%  } //нормально
};
A batalha por nanossegundos parece muito estranha diante de tais lacunas
1...8687888990919293949596
Novo comentário