错误、漏洞、问题 - 页 2451

新评论
[删除]  
名称中带有#的文件不能被添加到存储器中。这是正常的行为还是一个错误？
 

如果我们谈论的是外汇，在那里，滴答声不会使价格发生太大的变化（通常）。但在其他市场上，一个订单可能会因为一个小的方法而严重滑落。我仍然赞成在蜱虫之间进行尝试--我看不出有什么坏处，潜在的好处就在那里。

我们必须尝试...

 
行动中的滞后现象...关于隐式赋值复制 操作符在结构中如何工作的例子。

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

结果。
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:
行动中的滞后现象...通过一个例子来说明隐式复制操作符在结构中是如何工作的。

也许，为了发现这样的事情，人们不得不达到一种内部状态/愚蠢，即 "这里没有什么不可能的，但我还是要检查一下"，以寻找自己代码中的一个错误。

 
fxsaber:

我猜为了检测这样的事情，你必须达到 "这里不可能出错，但我还是要检查一下 "的内部状态/愚蠢的程度，以寻找你的代码中的错误。

该代码正在为一个特定的协议解析字节流。
已解压和未解压的数据（下一级封装的数据）不匹配。

 
Sergey Dzyublik:

该代码正在解析一个特定协议的字节流。
已解压和未解压的数据（下一级封装的数据）不匹配。

要检测这样的任务并不难。很幸运。
 
Sergey Dzyublik:
行动中的滞后现象...隐式复制操作符在结构中如何工作的一个例子。

问题是什么？

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

在MQL中，一个条件性条目

//                 a = b;

等同于

        ArrayCopy( a,  b );

结果。

        ArrayPrint( a );
}

2 2 3

 
A100:

问题是什么呢？


在我看来，赋值复制 操作者不仅应该复制数组元素 本身，还应该复制它们的编号，保留的内存量是有效的。

而现在实际上是以下情况。

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



源代码。

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:


复制操作者不仅要复制数组中的元素 本身，还要复制它们的编号，保留的内存数量不动。

那为什么

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

在(1)中的错误和在(2)中它是好的！？有什么区别？

不同的是，数组的复制不是通过规则a = b，而是通过规则ArrayCopy( a, b )

根据a=b的规则不存在，因为它不存在，如果它存在，错误（1）就不会存在


 
Igor Zakharov:

对每一个刻度进行计数是资源密集型的，特别是在策略测试器中。只在交易事件中重新计算不是更正确吗，也就是说，当未结头寸列表中的某些东西实际发生变化时，才重新计算？有了OnTradeTransaction()，更容易控制用户对EA的干预。(有一些先例 :)

在这个机器人中，我正在测试关闭网格的可能性：损失+利润>X，然后关闭它们（通常在不同的符号上）。但是，失败发生了，因为即使它们已经关闭，测试人员也没有意识到这一点，并继续进行下一次迭代，错误地将现有的与已经关闭的 "配对"。所以我不得不在每次关闭后增加一个重新计算。

我已经重新计算了计数器，并首先对所有打开的计数器进行了重新计算，而不是+1/-1。

我同意，最初使用OnTradeTransaction() 是有风险的。实际上，在我的请求不是异步 的情况下，我可能会拒绝使用它--它们只会引起麻烦。

这一点都不冒险。问题只在于组织行动和事件的顺序。傻瓜的建议是正确的--关闭这对组合，离开这个循环，直到下一次打勾。在下一个刻度，价格不一定比现在差。也许，晚一点关闭会更好，但不会混淆什么与什么关闭。

第二种变体：不是按照PositionsTotal来安排循环，而是按照事先创建的数组。而当关闭一些对子时，这些票子应该从阵列中删除。这将不允许已关闭的位置 再次被关闭。总的来说，是一种飞行的幻想和行动的逻辑。

1...244424452446244724482449245024512452245324542455245624572458...3184
新评论