Fehler, Irrtümer, Fragen

Igor Makanu 2019.07.07 14:32 #25001

fxsaber:

Das passiert.

Ich habe es so versucht:

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

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

wir löschen nur die ersten 4 Bytes

Igor Makanu 2019.07.07 14:42 #25002

einen anderen Weg versucht:

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

immer noch kein Ergebnis - löscht nur die ersten 4 Bytes

fxsaber 2019.07.07 14:49 #25003

Igor Makanu:

immer noch kein Ergebnis - löscht nur die ersten 4 Bytes

Denn physisch besteht die Struktur aus 4 Bytes.

Igor Makanu 2019.07.07 15:02 #25004

fxsaber:

Denn physisch ist die Struktur 4 Bytes groß.

ja, wir haben bereits herausgefunden, dass pack() innerhalb von MQL nicht funktioniert - ich habe keine weiteren Möglichkeiten,pack() zu überprüfen

Ich dachte über die Überprüfung in .dll in C#, aber es gibt ein Problem dort auch - MQL sieht die Signatur der aufgerufenen Funktion (erinnern Sie sich die const Aufruf in Signaturen nicht für C# arbeiten)

und bei der Übertragung von Daten nach C# wird es möglich sein, Typkonvertierung zu tun?

ZS: schreiben Sie höchstens eine .dll in C++ - dort können Sie "saubere" Daten empfangen / senden

[Archiv!] Jede Anfängerfrage, um Asynchrone und mehrfädige Programmierung Fragen zu OOP in

Alexey Viktorov 2019.07.07 15:09 #25005

fxsaber:

Ich weiß nicht mehr, ob es in der Dokumentation steht.

Danke, ich habe es gefunden. Meiner Meinung nach funktioniert alles. Da in Ihrem Beispiel nur ein Typ in der Struktur vorkommt, ist eine Anpassung nicht sinnvoll. Deshalb wird auch nur die Größe der Schrift angegeben. Und hier haben Sie

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

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

Hier ist die Struktur

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

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

Die Dokumentation erklärt dies sehr anschaulich mit Bildern.

Jede Anfängerfrage, um das EURUSD - Trends, Prognosen [WARNUNG GESCHLOSSEN!] Alle Fragen

Igor Makanu 2019.07.07 15:23 #25006

Alexey Viktorov:

Danke, ich habe es gefunden. Meiner Meinung nach funktioniert alles. Da in Ihrem Beispiel nur ein Typ in der Struktur vorkommt, ist eine Anpassung nicht sinnvoll. Deshalb wird auch nur die Schriftgröße angegeben. Und hier haben wir

Und diese Struktur

Die Dokumentation erklärt dies sehr anschaulich mit Bildern.

Ja, so funktioniert es:

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

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

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

total: pack() führt eine Datenausrichtung in der Struktur um die Größe des Feldes maximum sizeof() der Struktur durch

Errors, bugs, questions Fragen von Neueinsteigern zu Fragen zu OOP in

Alexey Viktorov 2019.07.07 15:29 #25007

Igor Makanu:

Zusammenfassung: pack() richtet die Daten in der Struktur nach der Größe des maximalen sizeof()-Feldes der Struktur aus

Nicht ganz.

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

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

Das maximale Feld ist 8 Bytes; wir setzen die Ausrichtung auf 4 und erhalten 16. Das ist 2+2|4|2+2|2+addshort doubleint

Oder 2+Zusatz|4|4|4

Igor Makanu 2019.07.07 15:47 #25008

Alexey Viktorov:

Nicht ganz.

Das maximale Feld ist 8 Byte, setzen Sie die Ausrichtung auf 4 und Sie erhalten 16. Also 2+2|4|2+2|2+add kurz doubleint

Oder 2+Zusatz|4|4|4

Ja, das sollte wohl richtig klingen:

zusammenfassend: pack() führt eine elementweise Ausrichtung der Daten in der Struktur durch; jedes Element wird mit einem Vielfachen des Wertes von pack() unter Berücksichtigung der maximalen sizeof() des Strukturelementsangehängt(nicht mehr als der maximale Wert, weniger kann beim Anhängen sein)

pack(4) :

kurz = 2 + 2 angehängt = 4=pack(4)

double =8 - nicht kollabieren

int =4 - nicht ausgerichtet

sizeof()=16 Bytes

Ermitteln der Anzahl der [Archiv!] Jede Anfängerfrage, um Mein Ansatz. Der Kern

Alexey Viktorov 2019.07.07 16:06 #25009

Igor Makanu:

Ja, so sollte es sich wahrscheinlich anhören:

total: pack() führt die Datenausrichtung in der Struktur Element für Element durch, jedes Element ist ein Vielfaches von pack() unter Berücksichtigung der maximalen sizeof() des Strukturelements (nicht mehr als der Maximalwert, weniger kann zusätzlich sein)

pack(4) :

kurz = 2 + 2 angehängt = 4=pack(4)

double =8 - nicht kollabieren

int =4 - nicht ausgerichtet

sizeof()=16 Bytes

Es klingt verworren, aber für mich macht es Sinn.))

fxsaber 2019.07.07 16:51 #25010

Alexey Viktorov:

Klingt kompliziert, ergibt für mich aber Sinn.)))

Forum zum Thema Handel, automatisierte Handelssysteme und Testen von Handelsstrategien

Wanzen, Wanzen, Fragen

fxsaber, 2019.07.07 15:03

DieReihenfolge der Felder wirkt sich auf den Speicherverbrauch und die Leistung aus.

Ich habe es noch nicht ganz verstehen können.

Merkmale der Sprache mql5, Wie verschiebe ich die Fragen von Anfängern MQL5

Fehler, Irrtümer, Fragen - Seite 2501