Erros, bugs, perguntas

Igor Makanu 2019.07.07 14:32 #25001

fxsaber:

Isto é o que acontece.

experimentou-o assim:

const uint FFFF=0xFFFFFFFF;
//+------------------------------------------------------------------+
struct A pack(4)
  {
   ushort            j1;
   ushort            j2;
  };
//+------------------------------------------------------------------+
struct B pack(8)
  {
   ushort            j1;
   ushort            j2;
  };
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
union UnionCheckByte
  {
   uint              byte_4x4[4];
   A                 a;
   B                 b;
  };
//+------------------------------------------------------------------+
void OnStart()
  {
   UnionCheckByte tst;
   tst.byte_4x4[0]=FFFF;   tst.byte_4x4[1]=FFFF;   tst.byte_4x4[2]=FFFF;   tst.byte_4x4[3]=FFFF;   // заполним память 0xFFFFFFFF FFFFFFFF
   ArrayPrint(tst.byte_4x4);
// A   
   Print("A:");
   tst.byte_4x4[0]=FFFF;   tst.byte_4x4[1]=FFFF;   tst.byte_4x4[2]=FFFF;   tst.byte_4x4[3]=FFFF;   // заполним память 0xFFFFFFFF FFFFFFFF
   A zeroA;
   ZeroMemory(zeroA);
   tst.a = zeroA;
   ArrayPrint(tst.byte_4x4);
   
// B
   Print("B:");
   tst.byte_4x4[0]=FFFF;   tst.byte_4x4[1]=FFFF;   tst.byte_4x4[2]=FFFF;   tst.byte_4x4[3]=FFFF;   // заполним память 0xFFFFFFFF FFFFFFFF
   B zeroB;
   ZeroMemory(zeroB);
   tst.b = zeroB;
   ArrayPrint(tst.byte_4x4);
 
   Print("sizeof(A) = ",sizeof(A)," , sizeof(B) = ",sizeof(B));
  }
//+------------------------------------------------------------------+

2019.07.07 18:31:02.708 tst (EURUSD,H1) 4294967295 4294967295 4294967295 4294967295 4294967295

2019.07.07 18:31:02.708 tst (EURUSD,H1) A

2019.07.07 18:31:02.708 tst (EURUSD,H1) 0 4294967295 4294967295 4294967295

2019.07.07 18:31:02.708 tst (EURUSD,H1) B

2019.07.07 18:31:02.708 tst (EURUSD,H1) 0 4294967295 4294967295 4294967295

2019.07.07 18:31:02.708 tst (EURUSD,H1) sizeof(A) = 4 , sizeof(B) = 4

continuamos a zerar apenas os primeiros 4 bytes

Igor Makanu 2019.07.07 14:42 #25002

tentou de outra forma:

const uint FFFF=0xFFFFFFFF;
//+------------------------------------------------------------------+
union UnionCheckByte
  {
   uint              byte_4x4[4];
   struct uA pack(4) {ushort j1; ushort j2; } a;
   struct uB pack(8) {ushort j1; ushort j2; } b;
  };
//+------------------------------------------------------------------+
void OnStart()
  {
   UnionCheckByte tst;
   tst.byte_4x4[0]=FFFF;   tst.byte_4x4[1]=FFFF;   tst.byte_4x4[2]=FFFF;   tst.byte_4x4[3]=FFFF;   // заполним память 0xFFFFFFFF FFFFFFFF
   ArrayPrint(tst.byte_4x4);
// A   
   Print("A:");
   tst.byte_4x4[0]=FFFF;   tst.byte_4x4[1]=FFFF;   tst.byte_4x4[2]=FFFF;   tst.byte_4x4[3]=FFFF;   // заполним память 0xFFFFFFFF FFFFFFFF
   
   ZeroMemory(tst.a);
   ArrayPrint(tst.byte_4x4);
   
// B
   Print("B:");
   tst.byte_4x4[0]=FFFF;   tst.byte_4x4[1]=FFFF;   tst.byte_4x4[2]=FFFF;   tst.byte_4x4[3]=FFFF;   // заполним память 0xFFFFFFFF FFFFFFFF
   ZeroMemory(tst.b);
   ArrayPrint(tst.byte_4x4);
 
   Print("sizeof(A) = ",sizeof(tst.a)," , sizeof(B) = ",sizeof(tst.b));
  }
//+------------------------------------------------------------------+

ainda sem resultado - apenas limpa os primeiros 4 bytes

fxsaber 2019.07.07 14:49 #25003

Igor Makanu:

ainda sem resultado - apenas limpa os primeiros 4 bytes

Porque fisicamente a estrutura é de 4 bytes.

Igor Makanu 2019.07.07 15:02 #25004

fxsaber:

Porque fisicamente a estrutura é de 4 bytes.

sim, já descobrimos que o pacote() não funciona dentro do MQL - não tenho mais opções para verificar opacote()

Pensei em verificar em .dll em C# mas também há lá um problema - MQL vê a assinatura da função chamada (lembre-se que a chamada constante em assinaturas não funcionou para C# )

e ao transferir dados para C# será possível fazer conversão de tipo?

ZS: no máximo, escreva um .dll em C++ - aí poderá "limpar" dados para receber / enviar

[Arquivo!] Qualquer pergunta de Programação assíncrona e multi-tarefa Perguntas de Iniciantes MQL5

Alexey Viktorov 2019.07.07 15:09 #25005

fxsaber:

Não me lembro se está na documentação.

Obrigado, encontrei-o. Tudo funciona, na minha opinião. Uma vez que no seu exemplo existe apenas um tipo na estrutura, não vale a pena alinhar. É por isso que apenas dá o tamanho do tipo. E aqui tem

struct A pack(4)
{
  short j;
  int   z;
};

void OnStart()
{
  Print(sizeof(A)); // 8
}

Aqui está a estrutura

struct A pack(8)
{
  short   j;
  double  x;
  int     b;
};

void OnStart()
{
  Print(sizeof(A)); // 24
}

A documentação explica-o muito claramente em imagens.

[Arquivo!] Qualquer pergunta de Perguntas de Iniciantes MQL5 Uma pergunta para aqueles

Igor Makanu 2019.07.07 15:23 #25006

Alexey Viktorov:

Obrigado, encontrei-o. Tudo funciona, na minha opinião. Uma vez que no seu exemplo existe apenas um tipo na estrutura, não vale a pena alinhar. É por isso que dá apenas o tamanho do tipo. E aqui temos

E esta estrutura

A documentação explica-o muito claramente em imagens.

Sim, é assim que funciona:

const uint FFFF=0xFFFFFFFF;
//+------------------------------------------------------------------+
union UnionCheckByte
  {
   uint              byte_4x4[4];
   struct uA pack(4) {ushort j1; ulong j2; } a;
   struct uB pack(8) {ushort j1; ulong j2; } b;
  };
//+------------------------------------------------------------------+
void OnStart()
  {
   UnionCheckByte tst;
   tst.byte_4x4[0]=FFFF;   tst.byte_4x4[1]=FFFF;   tst.byte_4x4[2]=FFFF;   tst.byte_4x4[3]=FFFF;   // заполним память 0xFFFFFFFF FFFFFFFF
   ArrayPrint(tst.byte_4x4);
// A   
   Print("A:");
   tst.byte_4x4[0]=FFFF;   tst.byte_4x4[1]=FFFF;   tst.byte_4x4[2]=FFFF;   tst.byte_4x4[3]=FFFF;   // заполним память 0xFFFFFFFF FFFFFFFF
   
   ZeroMemory(tst.a);
   ArrayPrint(tst.byte_4x4);
   
// B
   Print("B:");
   tst.byte_4x4[0]=FFFF;   tst.byte_4x4[1]=FFFF;   tst.byte_4x4[2]=FFFF;   tst.byte_4x4[3]=FFFF;   // заполним память 0xFFFFFFFF FFFFFFFF
   ZeroMemory(tst.b);
   ArrayPrint(tst.byte_4x4);
 
   Print("sizeof(A) = ",sizeof(tst.a)," , sizeof(B) = ",sizeof(tst.b));
  }
//+------------------------------------------------------------------+

2019.07.07 19:16:27.100 tst (EURUSD,H1) 4294967295 4294967295 4294967295 4294967295 4294967295

2019.07.07 19:16:27.100 tst (EURUSD,H1) A

2019.07.07 19:16:27.100 tst (EURUSD,H1) 0 0 0 0 0 4294967295

2019.07.07 19:16:27.100 tst (EURUSD,H1) B:

2019.07.07 19:16:27.100 tst (EURUSD,H1) 0 0 0 0 0

2019.07.07 19:16:27.100 tst (EURUSD,H1) sizeof(A) = 12 , sizeof(B) = 16

total: pack() realiza o alinhamento dos dados na estrutura pelo tamanho do campo de tamanho máximo de() da estrutura

Errors, bugs, questions Quaisquer perguntas de recém-chegados Perguntas sobre OOP em

Alexey Viktorov 2019.07.07 15:29 #25007

Igor Makanu:

resumo: pacote() alinha os dados na estrutura pelo tamanho do campo de tamanho máximo de() da estrutura

Não exactamente.

struct A pack(4)
{
  short   j;
  double  x;
  int     b;
};

void OnStart()
{
  Print(sizeof(A)); // 16
}

O campo máximo é de 8 bytes; fixamos o alinhamento em 4 e obtemos 16. Ou seja 2+2|4|2+2|2+add duplocurtoint

Ou 2+adição|4|4|4|4

Igor Makanu 2019.07.07 15:47 #25008

Alexey Viktorov:

Não exactamente.

O campo máximo é de 8 bytes, definir o alinhamento para 4 e obter 16. Então 2+2|4|2+2|2+add curto duploint

Ou 2+adição|4|4|4|4

sim, isso deve provavelmente soar bem:

em resumo: pack() realiza o alinhamento elemento por elemento dos dados na estrutura; cada elemento será anexado com um valor múltiplo de pack() tendo em conta o tamanho máximo de() do elemento da estrutura (não mais do que o valor máximo, menos pode estar em anexo)

pack(4) :

curto = 2 + 2 apenso = 4=pacote(4)

duplo =8 - não colapsar

int =4 - não alinhar

sizeof()=16 bytes

Perguntas sobre a linguagem Características da linguagem mql5, Obter o número de

Alexey Viktorov 2019.07.07 16:06 #25009

Igor Makanu:

sim, provavelmente é assim que deve soar:

total: pack() realiza o alinhamento dos dados no elemento de estrutura por elemento, cada elemento será um múltiplo de pack() tendo em conta o tamanho máximo de() do elemento de estrutura (não mais do que o valor máximo, menos pode ser, além disso)

pack(4) :

curto = 2 + 2 apenso = 4=pacote(4)

duplo =8 - não colapsar

int =4 - não alinhado

sizeof()=16 bytes

Parece convoluto, mas faz sentido para mim)).

fxsaber 2019.07.07 16:51 #25010

Alexey Viktorov:

Soa convoluto, mas faz sentido para mim))))

Fórum sobre comércio, sistemas automatizados de comércio e testes de estratégia comercial

Insectos, insectos, perguntas

fxsaber, 2019.07.07 15:03

Aordem dos campos afecta o consumo de memória e aparentemente o desempenho.

Ainda não foi capaz de o compreender totalmente.

Como posso mudar a Características da linguagem mql5, MetaTrader 5 Python User

Erros, bugs, perguntas - página 2501