对巴解组织的看法很有意思

Igor Makanu 2021.01.31 00:36 #71

fxsaber:

我这样写是因为我喜欢这样。这就是说，在调试时，情况会变得非常糟糕。

甚至在这个表达中。

很难弄清谁归还了什么。在更复杂的情况下（我一直在练习），这真的很难。

如果你想使用2-3个...让我们假设5个函数的执行结果由逻辑运算（或条件三元运算符）联合起来 - 我在githab或其他地方看到过，这段代码可以处理

但如果你有一打这样的 "好东西"...我认为，这是不实际的

Igor Makanu 2021.01.31 00:54 #72

Maxim Kuznetsov:

当然，我不是一个mql开发者。

但在C语言的切换中，会产生相当有效的二进制搜索，不会造成不必要的页面分页或缓存转储。所以，是的，它往往比通过数组和结构间接寻址要好。

开发者在某处写道，这里有类似的信息

只找到了这个。

关于交易、自动交易系统和策略测试的论坛

这是我在MQL5中找到的文章。

斯拉瓦, 2011.04.14 09:59

不，不幸的是，它不会。对于字符串类型，只有在...否则，如果...否则

在开关中使用整数类型，可以使分析器的代码速度提高数倍，如果

fxsaber 2021.01.31 01:09 #73

Igor Makanu:

但如果是一打左右的人...我认为，这是不实际的。

小怪物。

  static bool VirtualOrderSelect( const TICKET_TYPE Index, const int Select, const int Pool = MODE_TRADES )
  {
    return(VIRTUAL::SelectOrders ? VIRTUAL::SelectOrders.OrderSelect(Index, Select, Pool) :
           #ifdef  VIRTUAL_SNAPSHOT_REFRESHTIME
             VIRTUAL::SnapshotPtr ?
             #ifdef __MQL5__ // Выбор по тикету в MT5 - разнообразный набор вариантов.
               (Select == SELECT_BY_TICKET) ? ::OrderSelect(Index, Select, Pool) && VIRTUAL::SnapshotPtr.CopyOrder()
                                            :
             #endif // #ifdef __MQL5__
                                              ((((Index == INT_MIN) || (Index == INT_MAX)) && (Pool == MODE_TRADES) &&
                                               ::OrderSelect(Index, Select, Pool) &&
                                             #ifdef  VIRTUAL_SNAPSHOT_WITHOUT_HISTORY
                                               VIRTUAL::SnapshotPtr.CopyOrder(true))
                                             #else // #ifdef VIRTUAL_SNAPSHOT_WITHOUT_HISTORY
                                               VIRTUAL::SnapshotPtr.CopyOrder())
                                             #endif // #ifdef VIRTUAL_SNAPSHOT_WITHOUT_HISTORY #else
                                               || VIRTUAL::SnapshotPtr.OrderSelect(Index, Select, Pool))
                                  :
           #endif // #ifdef VIRTUAL_SNAPSHOT_REFRESHTIME
           #ifdef __MQL5__
             #ifdef __MT4ORDERS__
               ::OrderSelect(Index, Select, Pool)
             #else // __MT4ORDERS__
               false
             #endif // __MT4ORDERS__
           #else // __MQL5__
             ::OrderSelect(Index, Select, Pool)
           #endif // __MQL5__
           );
  }

逻辑操作允许你在通过宏使用不同的设置时简洁地进行编写。但这是一种恐怖，当然了。

Igor Makanu 2021.01.31 01:26 #74

fxsaber:

逻辑操作允许在通过宏使用各种设置时进行简洁的编写。但这是一种恐怖，当然了。

你的例子来自 "目的决定手段"。

我的问题是关于一个非常不同的和不可理解的风格

traveller00 2021.01.31 04:55 #75

fxsaber:

那个小怪物。

你不能看着礼物马的嘴。但这里还有几个别人的代码的例子，它们给了我几段难忘的几十分钟的调试时间。也许有人会认识到自己的代码。

      Res = (!FillingMode || (Type >= ORDER_FILLING_RETURN) || ((FillingMode & (Type + 1)) != Type + 1)) ?
            (((ExeMode == SYMBOL_TRADE_EXECUTION_EXCHANGE) || (ExeMode == SYMBOL_TRADE_EXECUTION_INSTANT)) ?
             ORDER_FILLING_RETURN : ((FillingMode == SYMBOL_FILLING_IOC) ? ORDER_FILLING_IOC : ORDER_FILLING_FOK)) :
            (ENUM_ORDER_TYPE_FILLING)Type;

    return((arrow_color == INT_MAX) ? (MT4ORDERS::NewOrderCheck() ? 0 : -1) :
           ((((int)arrow_color != INT_MIN) || MT4ORDERS::NewOrderCheck()) &&
            MT4ORDERS::OrderSend(MT4ORDERS::LastTradeRequest, MT4ORDERS::LastTradeResult) ?
            (MT4ORDERS::IsHedging ? (long)MT4ORDERS::LastTradeResult.order : // PositionID == Result.order - особенность MT5-Hedge
             ((MT4ORDERS::LastTradeRequest.action == TRADE_ACTION_DEAL) ?
              (MT4ORDERS::IsTester ? (_B2(::PositionSelect(MT4ORDERS::LastTradeRequest.symbol)) ? PositionGetInteger(POSITION_TICKET) : 0) :
                                      // HistoryDealSelect в MT4ORDERS::OrderSend
                                      ::HistoryDealGetInteger(MT4ORDERS::LastTradeResult.deal, DEAL_POSITION_ID)) :
              (long)MT4ORDERS::LastTradeResult.order)) : -1));

我不知道这样写是否容易，但调试起来很不真实，读起来就更不真实了。而且我看不出有任何客观的理由把它写成这样。

fxsaber 2021.01.31 09:06 #76

traveller00:

而且我看不出有任何客观的理由把它写成这样。

当然，它们是主观的。我不喜欢不必要的变量和多重回报。出于某种原因，我相信没有他们，EX5会更短，执行得更快。

Aleksey Mavrin 2021.01.31 10:13 #77

fxsaber:

当然，它们是主观的。我不喜欢不必要的变量和多重回报。出于某种原因，我相信没有他们，EX5会更短更快。

顺便说一下，这种认为代码会更短更快的信心是没有道理的。

在这里，它是

bool a=A();
bool b=B();
//....много промежуточных результатов
bool x=X();
bool Res=a||b||x ;
return Res;

而这

return A()||B()||X();

我相信在速度上会是一样的（也许在代码的大小和使用的内存上也是一样的）。

只是第二种变体写起来比较快，大家都在写，然后，当有必要增加/复杂化一些东西时，他们就留下第二种变体，但却臃肿成难以阅读的样子。

你应该定期进行这方面的重构，你就不会有麻烦。

fxsaber 2021.01.31 10:26 #78

Aleksey Mavrin:

定期在这方面进行重构将不是问题。

只有那些有大量空闲时间的人，或者客观上被压得没有地方可去的人。

当有大量的回报时，代码将100%的不同。

Aleksey Mavrin 2021.01.31 10:33 #79

fxsaber:

只有那些有大量空闲时间的人，或者客观上被压得没有地方可去的人。

ZS 当有大量的回报时，代码将100％是不同的。

我理解，但部分同意，我只是认为每个人都经历过相对较长的错误修复时间，如果代码 "完全准备好 "进行调试，这些错误会被更快地发现。

目前还不清楚什么会耗费更多的时间--更长的时间来编写 "可用的 "代码，还是调试和寻找错误，我想这总是不同的。

Igor Makanu 2021.01.31 11:52 #80

fxsaber:

当有大量的回报时，代码将是100%的不同。

调试器下的C++ VS2019

源代码。

bool a(int v) { return(v > 0); }
bool b(int v) { return(v < 0); }
bool c(int v) { return(v == 0);}

bool tst1(int v1, int v2, int v3)
{
        if (a(v1)) return(true);
        if (b(v2)) return(true);
        if (c(v3)) return(true);
        return(false);
}

bool tst2(int v1, int v2, int v3)
{
        return(a(v1) && b(v2) && c(v3));
}

int main()
{
        int x = 1, y=2, z=3;
        bool result1 = tst1(x, y, z);
        bool result2 = tst2(x, y, z);
}

ASM调试器

bool tst1(int v1, int v2, int v3)
{
        if (a(v1)) return(true);
000 E1918  mov         eax,dword ptr [v1]  
000 E191B  push        eax  
000 E191C  call        a (0 E137Ah)  
000 E1921  add         esp,4  
000 E1924  movzx       ecx,al  
000 E1927  test        ecx,ecx  
000 E1929  je          tst1+3 Fh (0 E192Fh)  
000 E192B  mov         al,1  
000 E192D  jmp         tst1+6 Fh (0 E195Fh)  
        if (b(v2)) return(true);
000 E192F  mov         eax,dword ptr [v2]  
000 E1932  push        eax  
000 E1933  call        b (0 E13ACh)  
000 E1938  add         esp,4  
000 E193B  movzx       ecx,al  
000 E193E  test        ecx,ecx  
000 E1940  je          tst1+56 h (0 E1946h)  
000 E1942  mov         al,1  
000 E1944  jmp         tst1+6 Fh (0 E195Fh)  
        if (c(v3)) return(true);
000 E1946  mov         eax,dword ptr [v3]  
000 E1949  push        eax  
000 E194A  call        c (0 E11B8h)  
000 E194F  add         esp,4  
000 E1952  movzx       ecx,al  
000 E1955  test        ecx,ecx  
000 E1957  je          tst1+6 Dh (0 E195Dh)  
000 E1959  mov         al,1  
000 E195B  jmp         tst1+6 Fh (0 E195Fh)  
        return(false);
000 E195D  xor         al,al  
}

bool tst2(int v1, int v2, int v3)
{
        return(a(v1) && b(v2) && c(v3));
000 E19C8  mov         eax,dword ptr [v1]  
000 E19CB  push        eax  
000 E19CC  call        a (0 E137Ah)  
000 E19D1  add         esp,4  
000 E19D4  movzx       ecx,al  
000 E19D7  test        ecx,ecx  
000 E19D9  je          tst2+6 Dh (0 E1A0Dh)  
000 E19DB  mov         edx,dword ptr [v2]  
000 E19DE  push        edx  
000 E19DF  call        b (0 E13ACh)  
000 E19E4  add         esp,4  
000 E19E7  movzx       eax,al  
000 E19EA  test        eax,eax  
000 E19EC  je          tst2+6 Dh (0 E1A0Dh)  
000 E19EE  mov         ecx,dword ptr [v3]  
000 E19F1  push        ecx  
000 E19F2  call        c (0 E11B8h)  
000 E19F7  add         esp,4  
000 E19FA  movzx       edx,al  
000 E19FD  test        edx,edx  
000 E19FF  je          tst2+6 Dh (0 E1A0Dh)  
000 E1A01  mov         dword ptr [ebp-0 C4h],1  
000 E1A0B  jmp         tst2+77 h (0 E1A17h)  
000 E1A0D  mov         dword ptr [ebp-0 C4h],0  
000 E1A17  mov         al,byte ptr [ebp-0 C4h]  
}

通过命令减少了一个电话，只是在2个栏目中不计算在内。

ts1:                                                    tst2:
000 E1918  mov         eax,dword ptr [v1]                000 E19C8  mov         eax,dword ptr [v1]
000 E191B  push        eax                               000 E19CB  push        eax  
000 E191C  call        a (0 E137Ah)                       000 E19CC  call        a (0 E137Ah)  
000 E1921  add         esp,4                             000 E19D1  add         esp,4  
000 E1924  movzx       ecx,al                            000 E19D4  movzx       ecx,al  
000 E1927  test        ecx,ecx                           000 E19D7  test        ecx,ecx  
000 E1929  je          tst1+3 Fh (0 E192Fh)                000 E19D9  je          tst2+6 Dh (0 E1A0Dh)  
000 E192B  mov         al,1                              000 E19DB  mov         edx,dword ptr [v2]  
000 E192D  jmp         tst1+6 Fh (0 E195Fh)                000 E19DE  push        edx

正如你在这里看到的，这些命令几乎是相互重复的，很明显，在第一个测试中，你需要增加一些返回值

有99%的信心，我认为在处理器层面，这些代码将以相同的速度运行，直到一个时钟 - 在处理器的优化，并联和谁知道还有什么在微命令层面起作用。

对巴解组织的看法很有意思 - 页 8