Erreurs, bugs, questions - page 2501

 

a essayé un autre moyen :

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

toujours pas de résultat - efface seulement les 4 premiers octets

 
Igor Makanu:

toujours aucun résultat - efface seulement les 4 premiers octets

Parce que physiquement la structure est de 4 octets.

 
fxsaber:

Parce que physiquement la structure est de 4 octets.

oui, nous avons déjà compris que pack() ne fonctionne pas dans MQL - je n'ai pas d'autres options pour vérifierpack()

J'ai pensé à vérifier les .dll en C#, mais là aussi, il y a un problème - MQL voit la signature de la fonction appelée (rappelez-vous que l'appel constant dans les signatures ne fonctionnait pas en C#).

et lors du transfert des données vers C#, sera-t-il possible de faire une conversion de type ?

ZS : au maximum, écrivez une .dll en C++ - vous pouvez y recevoir / envoyer des données "propres".

 
fxsaber:

Je ne me souviens pas si c'est dans la documentation.

Merci, je l'ai trouvé. Tout fonctionne à mon avis. Puisque dans votre exemple il n'y a qu'un seul type dans la structure, il n'y a pas d'intérêt à l'alignement. C'est pourquoi il ne donne que la taille du type. Et ici vous avez

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

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

Voici la structure

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

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

La documentation l'explique très clairement en images.


 
Alexey Viktorov:

Merci, je l'ai trouvé. Tout fonctionne à mon avis. Puisque dans votre exemple, il n'y a qu'un seul type dans la structure, l'alignement n'a pas de sens. C'est pourquoi il ne donne que la taille des caractères. Et ici nous avons

Et cette structure

La documentation l'explique très clairement en images.


Oui, c'est comme ça que ça marche :

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 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() effectue l'alignement des données dans la structure par la taille du champ sizeof() maximum de la structure

 
Igor Makanu:

résumé : pack() aligne les données dans la structure par la taille du champ sizeof() maximum de la structure

Pas exactement.

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

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

Le champ maximal est de 8 octets ; nous fixons l'alignement à 4 et obtenons 16. C'est 2+2|4|2+2|2+addshort doubleint

Ou 2+addition|4|4|4

 
Alexey Viktorov:

Pas exactement.

Le champ maximum est de 8 octets, mettez l'alignement à 4 et obtenez 16. Donc 2+2|4|2+2|2+add short doubleint

Ou 2+addition|4|4|4

Oui, ça devrait sonner juste :

en résumé : pack() effectue un alignement élément par élément des données dans la structure ; chaque élément sera ajouté avec une valeur multiple de pack() en tenant compte de la taille maximale sizeof() de l'élément de la structure (pas plus que la valeur maximale, moins peut être dans l'ajout)

pack(4) :

court = 2 + 2 annexés = 4=pack(4)

double =8 - ne pas réduire

int =4 - non aligné

sizeof()=16 octets

 
Igor Makanu:

Oui, c'est probablement comme ça que ça devrait sonner :

total : pack() effectue l'alignement des données dans la structure élément par élément, chaque élément sera un multiple de pack() en tenant compte de la taille maximale sizeof() de l'élément de la structure (pas plus que la valeur maximale, moins peut être en plus)

pack(4) :

court = 2 + 2 annexés = 4=pack(4)

double =8 - ne pas réduire

int =4 - non aligné

sizeof()=16 octets

Cela semble alambiqué, mais cela a du sens pour moi.))

 
Alexey Viktorov:

Ça semble alambiqué, mais ça a du sens pour moi.)))

Forum sur le trading, les systèmes de trading automatisé et les tests de stratégies de trading

Bugs, bugs, questions

fxsaber, 2019.07.07 15:03

L'ordre des champs affecte la consommation de mémoire et, apparemment, les performances.

Je n'ai pas encore été capable de le comprendre complètement.

 
fxsaber:

Je n'ai pas encore trouvé de solution.

Non pas à partir de l'ordre des champs, mais à partir de la valeur maximale et de la valeur fixée de pack() ; de plus, cela dépend de l'ordre des champs.

Maintenant, j'ai fait la variante suivante

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

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

Il ne s'aligne pas sur 16 comme spécifié dans pack(), mais sur 8 par le double maximal.