Fehler, Irrtümer, Fragen - Seite 2451

Neuer Kommentar
 
Eine Datei mit einem # in ihrem Namen kann nicht zum Speicher hinzugefügt werden. Ist dieses Verhalten normal oder ein Fehler?
 

Wenn es sich um Devisen handelt, verändern die Ticks den Preis (normalerweise) nicht sehr. Aber auf anderen Märkten kann ein Auftrag mit einem ticky Ansatz ernsthaft entgleiten. Ich bin immer noch dafür, es zwischen den Zecken zu versuchen - ich sehe keinen Schaden, der potenzielle Nutzen ist da.

Wir müssen versuchen...

 
Hysterese in Aktion... ein Beispiel dafür, wie ein impliziter Zuweisungskopieroperator in Strukturen funktioniert.

#define  PRINT(x) Print(#x, ":", string(x))

struct MyArray{
   uchar data[];
};


void OnStart(){
   MyArray tmp_arr;
   
   MyArray huge_arr;
   ArrayResize(huge_arr.data, 1000);
   ArrayInitialize(huge_arr.data, 0x8);
   
   MyArray small_arr;
   ArrayResize(small_arr.data, 10);
   ArrayInitialize(small_arr.data, 0x1);
   
   
   tmp_arr = small_arr;
   Print("\r\nTest with small_arr");
   PRINT(ArraySize(tmp_arr.data));
   PRINT(tmp_arr.data[0]);
   PRINT(tmp_arr.data[ArraySize(tmp_arr.data)-1]);
   
   tmp_arr = huge_arr;
   Print("\r\nTest with huge_arr");
   PRINT(ArraySize(tmp_arr.data));
   PRINT(tmp_arr.data[0]);
   PRINT(tmp_arr.data[ArraySize(tmp_arr.data)-1]);
   
   tmp_arr = small_arr;
   Print("\r\nTest with small_arr");
   PRINT(ArraySize(tmp_arr.data));
   PRINT(tmp_arr.data[0]);
   PRINT(tmp_arr.data[ArraySize(tmp_arr.data)-1]);
}

Ergebnis:
2019.05.03 14:29:14.005 Test_push (EURUSD,H1)   Test with small_arr
2019.05.03 14:29:14.005 Test_push (EURUSD,H1)   ArraySize(tmp_arr.data):10
2019.05.03 14:29:14.005 Test_push (EURUSD,H1)   tmp_arr.data[0]:1
2019.05.03 14:29:14.005 Test_push (EURUSD,H1)   tmp_arr.data[ArraySize(tmp_arr.data)-1]:1
2019.05.03 14:29:14.005 Test_push (EURUSD,H1)   
2019.05.03 14:29:14.005 Test_push (EURUSD,H1)   Test with huge_arr
2019.05.03 14:29:14.005 Test_push (EURUSD,H1)   ArraySize(tmp_arr.data):1000
2019.05.03 14:29:14.005 Test_push (EURUSD,H1)   tmp_arr.data[0]:8
2019.05.03 14:29:14.005 Test_push (EURUSD,H1)   tmp_arr.data[ArraySize(tmp_arr.data)-1]:8
2019.05.03 14:29:14.005 Test_push (EURUSD,H1)   
2019.05.03 14:29:14.005 Test_push (EURUSD,H1)   Test with small_arr
2019.05.03 14:29:14.005 Test_push (EURUSD,H1)   ArraySize(tmp_arr.data):1000
2019.05.03 14:29:14.005 Test_push (EURUSD,H1)   tmp_arr.data[0]:1
2019.05.03 14:29:14.005 Test_push (EURUSD,H1)   tmp_arr.data[ArraySize(tmp_arr.data)-1]:8
 
Sergey Dzyublik:
Hysterese in Aktion... durch ein Beispiel, wie ein impliziter Kopieroperator in Strukturen funktioniert.

Wahrscheinlich musste man, um so etwas zu entdecken, auf der Suche nach einem Fehler im eigenen Code einen inneren Zustand der Dummheit erreichen, nach dem Motto "hier kann nichts funktionieren, aber ich werde es trotzdem überprüfen".

 
fxsaber:

Ich schätze, um so etwas zu entdecken, mussten Sie auf der Suche nach einem Fehler in Ihrem Code einen inneren Zustand bzw. eine Dummheit erreichen, die besagt: "Hier kann nichts schief gehen, aber ich prüfe es trotzdem".

Der Code analysierte den Byte-Stream für ein bestimmtes Protokoll.
Ausgepackte und ausgepackte Daten (Daten für die nächste Verkapselungsebene) stimmten nicht überein.

 
Sergey Dzyublik:

Der Code analysierte den Byte-Stream für ein bestimmtes Protokoll.
Ausgepackte und ausgepackte Daten (Daten für die nächste Verkapselungsebene) stimmten nicht überein.

Es ist nicht schwer, eine solche Aufgabe zu erkennen. Glücklich.
 
Sergey Dzyublik:
Hysterese in Aktion... Ein Beispiel dafür, wie ein impliziter Kopieroperator in Strukturen funktioniert.

Wie lautet die Frage?

void OnStart()
{
        int a[]; ArrayResize( a, 3 ); ArrayInitialize( a, 3 );
        int b[]; ArrayResize( b, 2 ); ArrayInitialize( b, 2 );

In MQL, ein bedingter Eintrag

//                 a = b;

ist gleich

        ArrayCopy( a,  b );

Ergebnis:

        ArrayPrint( a );
}

2 2 3

 
A100:

Wie lautet die Frage?


Meiner Meinung nach sollte der Zuweisungs-Kopier-Operator nicht nur die Array-Elemente selbst, sondern auch deren Anzahl kopieren, so dass die Menge des reservierten Speichers gültig bleibt.

Und jetzt ist es praktisch das Folgende:

int size;
size = 4; // size == 4
size = 8; // size == 8
size = 4; //  size == 8



Quellcode:

struct MyArray{
   uchar data[];
}

MyArray GetArray(int i){
   MyArray arr;
   
   if (i%2 == 0){
      ArrayResize(arr.data, 8);
      ArrayInitialize(arr.data, 0x8);
   }else{
      ArrayResize(arr.data, 4);
      ArrayInitialize(arr.data, 0x4);
   }
   return arr;
}

void OnStart(){
   MyArray arr_1 = GetArray(1);
   ArrayPrint(arr_1.data);		// 4 4 4 4
   
   MyArray arr_2 = GetArray(2);         
   ArrayPrint(arr_2.data);              // 8 8 8 8 8 8 8 8
   
   arr_2 = arr_1;
   ArrayPrint(arr_2.data);              // 4 4 4 4 8 8 8 8
}
 
Sergey Dzyublik:


Der Kopieroperator sollte nicht nur die Elemente des Arrays selbst, sondern auch deren Anzahl kopieren, wobei der reservierte Speicherplatz erhalten bleibt.

Warum dann

struct MyArray {
        uchar data[];
};
void OnStart()
{
        { uchar   a[], b[]; a = b; } //(1) Error
        { MyArray a,   b;   a = b; } //(2) нормально
}

in (1) der Fehler und in (2) ist alles in Ordnung!? Was ist der Unterschied?

Der Unterschied besteht darin, dass Arrays nicht nach der Regel a = b kopiert werden, sondern nach der Regel ArrayCopy( a, b )

Nicht nach der Regel a = b, denn es gibt sie nicht, und wenn es sie gäbe, gäbe es den Fehler (1) nicht.


 
Igor Zakharov:

Die Zählung jedes Ticks ist ressourcenintensiv, insbesondere beim Strategietester. Wäre es nicht korrekter, nur das Ereignis "Handel" neu zu berechnen, d. h. wenn sich etwas in der Liste der offenen Positionen tatsächlich ändert? Mit OnTradeTransaction() ist es einfacher, Benutzereingriffe in den EA zu kontrollieren. (Es gibt einige Präzedenzfälle :)

In diesem Roboter habe ich die Möglichkeit getestet, das Raster nach dem Schema: Verlust + Gewinn > X zu schließen, und dann beide zu schließen (normalerweise auf verschiedenen Symbolen). Aber es kommt zu einem Fehler, denn obwohl sie abgeschlossen sind, ist sich der Prüfer dessen nicht bewusst und fährt mit der nächsten Iteration fort, wobei er fälschlicherweise die vorhandenen mit den bereits abgeschlossenen "paart". Daher musste ich nach jedem Abschluss eine Neuberechnung vornehmen.

Ich habe Neuberechnung mit Zählerrückstellung und auf alle offenen zuerst, nicht +1 / -1

Ich stimme zu, dass es riskant war , zunächst OnTradeTransaction() zu verwenden. Tatsächlich werde ich mich wahrscheinlich weigern, es in Fällen zu verwenden, in denen meine Anfragen nicht asynchron sind - sie verursachen nur Probleme.

Es ist überhaupt nicht riskant. Die einzige Frage ist die Organisation der Abfolge von Aktionen und Ereignissen. Der Rat von Fool ist richtig: Schließen Sie das Paar und lassen Sie die Schleife bis zum nächsten Tick. Beim nächsten Tick sind die Preise nicht unbedingt schlechter als sie sind. Vielleicht ist es besser, sie etwas später zu schließen, aber es wird keine Verwirrung darüber geben, was mit was geschlossen wurde.

Die zweite Variante: Ordnen Sie die Schleife nicht nach PositionsTotal, sondern nach dem zuvor erstellten Array. Und wenn ein Paar geschlossen wird, sollten diese Tickets aus dem Array entfernt werden. Dadurch können die geschlossenen Positionen nicht wieder geschlossen werden. Im Allgemeinen ein Höhenflug und eine Logik des Handelns.

1...244424452446244724482449245024512452245324542455245624572458...3184
Neuer Kommentar
Grund der Beschwerde: