Fragen zu OOP in MQL5 - Seite 91

Neuer Kommentar
 
Dmitry Fedoseev:

Warum sollte es plötzlich nicht mehr funktionieren? Drei Aufzählungen, keine davon mehr als 10. Rechnen in der zweiten Klasse der Mittelschule.

3 Aufzählungen plus 2 int, Sie benötigen 4 Bytes = int

int brauche ich im Bereich +1000 -... +1000 , Pips, das sind gerade mal 2^10

int int's sind eine Überlegung wert, der Schritt von 1 Pips ist nicht wichtig, 2,5-...9 Pips sind auch möglich, d.h. die Diskretion ist nicht sehr kritisch

 
Igor Makanu:

3 Aufzählungen plus 2 int, benötigt 4 Bytes

int brauche ich im Bereich +1000 -... +1000 , Pips, das sind gerade mal 2^10

int int's sind eine Überlegung wert, 1 Pip-Schritte sind nicht wichtig, man kann 2,5-...9 pps haben, d.h. Diskretion ist nicht so kritisch

Es gibt mehr als genug Platz. INT_MAX=2147483647.

Wir könnten Zehner statt geradlinig und unverblümt verwenden und 8*8*4 sparsam einsetzen. Sie müssen nur denken))) Aber das ist nicht nötig, es passt sowieso alles rein.

Und zur Überprüfung - warum nicht den Zyklus bis INT_MAX starten - die Hardware wird es überprüfen, nicht die Datei mit den Ergebnissen selbst durchsehen.

 
Dmitry Fedoseev:

Mehr als genug Platz. INT_MAX=2147483647.

Man kann auch nicht dumm und gerade - Zehner besetzen, und sparsam, in der Not - 8*8*4 machen. Sie müssen nur denken))) Aber das ist nicht nötig, es passt sowieso alles rein.

Und zur Überprüfung - warum nicht einen Zyklus bis INT_MAX machen - es wird von der Hardware überprüft, wir müssen die Ergebnisdatei nicht selbst durchsehen.

Es macht mir nichts aus... Ich brauche den Code, um ihn auszuwerten, und die Methodik ist wichtiger als die Art der Konvertierung.

 
Igor Makanu:

Es macht mir nichts aus... Ich brauche den Code, um ihn zu bewerten, und die Testmethodik ist wichtiger als die Art der Konvertierung.

Bitweises Priming, nicht wahr? Es ist wie die Umwandlung einer Zahl in eine Zeichenkette mit bitweisen Werten. Eine für ganze Zahlen und eine für Punkte und Häkchen. Das ist nur für Debugging-Zwecke.

 
Alexandr Andreev:

Bitweise überschreiben, oder? So etwas wie die Aneinanderreihung einer Zahl mit bitweisen Werten. Eine für ganze Zahlen und eine für Punkte und Häkchen. Das ist nur für Debugging-Zwecke.

Ja, das ist klar, aber wie lässt sich die Überprüfung automatisieren?

das Problem, nicht in meinem Beispiel, aber in der Tatsache, dass ich noch in 3 int's von anderen Daten packen müssen, möchte ich nicht zu viel Zeit auf die Überprüfung jedes Paket verbringen


ZS: die Idee ist hell, aber nicht bitweise Werte, sondern hex - von printf() können Sie erhalten, oder eher von stringformat()

 
Igor Makanu:

Ja, das ist alles klar, aber wie kann man die Kontrolle automatisieren?

Das Problem, nicht in meinem Beispiel, aber in der Tatsache, dass ich noch in 3 int's von anderen Daten packen müssen, möchte ich nicht eine Menge Zeit auf die Überprüfung jedes Paket zu verbringen


HH: gute Idee, aber nicht bitweise, sondern hexadezimal - wir können sie von printf() oder eher von stringformat() erhalten

)) kann nicht herausfinden, was benötigt wird

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

Wollen wir einen Offset automatisieren oder was?

Was ist das für ein Scheck?

Und wir können jederzeit einfach die Quelle und die umgewandelten Werte überprüfen.

 
Igor Makanu:

Es macht mir nichts aus... Sie brauchen den Code, um ihn zu bewerten, und die Methodik der Überprüfung ist wichtiger als die Art der Konvertierung.

Wenn die Methodik der Umstellung klar und verständlich ist, besteht kein großer Bedarf an einer Überprüfung.

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

Nun, es ist offensichtlich, dass es mehr Variablen für mich ist es besser, nur Byte Kopieren von Strukturen (wahrscheinlich der Prozess erfordert keine starke Optimierung der Geschwindigkeit, sondern Komfort wird an einer Prämie sein)

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

Billig und billig

1...84858687888990919293949596
Neuer Kommentar