Interessante assumir a OLP

Igor Makanu 2021.01.30 23:36 #71

fxsaber:

Eu escrevo assim porque gosto. Dito isto, fica muito ruim quando se depura.

Mesmo nesta expressão.

é difícil descobrir quem devolveu o quê. Nas mais complexas (eu pratico isso o tempo todo) é realmente difícil.

Se você quiser usar 2-3... vamos assumir 5 resultados de execução de funções unidos por operações lógicas (ou operador ternário condicional) - eu vi no githab ou em outro lugar, este código pode ser manipulado

Mas se você tem uma dúzia dessas "guloseimas"... imho, não é prático

Por que eles não Item VS Peep A EA não funcionará

Igor Makanu 2021.01.30 23:54 #72

Maxim Kuznetsov:

Eu não sou um desenvolvedor de mql, é claro,

mas no switch C gera uma busca binária bastante eficiente e não causa paginação desnecessária ou despejo de cache. Portanto, sim, muitas vezes é melhor do que o endereçamento indireto através de matrizes e estruturas.

os desenvolvedores escreveram em algum lugar e aqui informações semelhantes

encontrou apenas isto:

Fórum sobre comércio, sistemas automatizados de comércio e testes estratégicos

Este é o artigo que encontramos na MQL5.

Slava, 2011.04.14 09:59

Não, infelizmente não vai. Para tipos de cordas somente se ... caso contrário, se ... senão

O uso de tipos inteiros no interruptor acelera o código do analisador várias vezes mais do que se

Aprender e escrever juntos Como começar com o suporte mql5.com?

fxsaber 2021.01.31 00:09 #73

Igor Makanu:

Mas se for uma dúzia ou mais... imho, não é prático.

Pequeno monstro.

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

As operações lógicas permitem que você escreva sucintamente ao utilizar diferentes configurações via macros. Mas é um horror, é claro.

Igor Makanu 2021.01.31 00:26 #74

fxsaber:

Asoperações lógicas permitem uma escrita concisa ao utilizar várias configurações através de macros. Mas é um horror, é claro.

Seu exemplo de "os fins justificam os meios".

minha pergunta era sobre um estilo muito diferente e incompreensível

traveller00 2021.01.31 03:55 #75

fxsaber:

O pequeno monstro.

Não se pode olhar um cavalo de presente na boca. Mas aqui estão mais alguns exemplos do código de outras pessoas, que me deram algumas dúzias inesquecíveis de minutos de depuração. Talvez alguém reconheça seu próprio código.

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

Não sei se foi fácil escrevê-lo dessa maneira, mas é irreal para depurá-lo, ainda mais para lê-lo. E não vejo nenhuma razão objetiva para escrevê-lo dessa maneira.

Perguntas de um "boneco" Idéias em bruto Indicadores de elite :)

fxsaber 2021.01.31 08:06 #76

traveller00:

E não vejo nenhuma razão objetiva para escrevê-lo dessa maneira.

Eles são subjetivos, é claro. Eu não gosto de variáveis desnecessárias e retornos múltiplos. Por alguma razão, acredito que o EX5 será mais curto e executado mais rapidamente sem eles.

Aleksey Mavrin 2021.01.31 09:13 #77

fxsaber:

Eles são subjetivos, é claro. Eu não gosto de variáveis desnecessárias e retornos múltiplos. Por alguma razão, acredito que o EX5 será mais curto e mais rápido sem eles.

A propósito, esta confiança de que o código será mais curto e mais rápido não se justifica.

aqui está

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

e isto

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

Tenho certeza de que será o mesmo em velocidade (e talvez em tamanho de código e memória utilizados).

É que a segunda variante é mais rápida de escrever e todos a escrevem e então, quando é necessário acrescentar/complicar algo, eles deixam a segunda variante mas inchada para uma de difícil leitura.

Você deve realizar a refatoração periodicamente a este respeito e não terá problemas.

O "New Neural" é [AVISO FECHADO!] Qualquer pergunta O parâmetro de escorregamento

fxsaber 2021.01.31 09:26 #78

Aleksey Mavrin:

Faça a refatoração periodicamente a este respeito e não haverá problemas.

Somente para aqueles que têm muito tempo livre ou estão objetivamente tão pressionados que não há para onde ir sem ele.

Quando há um grande retorno, o código será 100% diferente.

Aleksey Mavrin 2021.01.31 09:33 #79

fxsaber:

Somente para aqueles que têm muito tempo livre ou estão objetivamente tão pressionados que não há para onde ir sem ele.

ZS Quando há um grande retorno, o código será 100% diferente.

Entendo, mas concordo em parte, apenas acho que todos passaram por tempos relativamente longos de correção de erros, que seriam encontrados mais rapidamente se o código estivesse "perfeitamente pronto" para a depuração.

Não está claro o que consome mais tempo - mais tempo escrevendo código "utilizável" ou depurando e encontrando bugs, é sempre diferente, suponho.

Perguntas de Iniciantes MQL5 Da teoria à prática Quaisquer perguntas de recém-chegados

Igor Makanu 2021.01.31 10:52 #80

fxsaber:

Quando houver um grande retorno, o código será 100% diferente.

C++ VS2019 sob depuração

código fonte:

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

depurador 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]  
}

reduzido por comandos de uma chamada apenas em 2 colunas para não contar:

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

como você pode ver aqui e os comandos quase se repetem, é claro que no primeiro teste você precisa adicionar mais algum retorno

com 99% de confiança, acho que no nível do processador esses códigos funcionarão na mesma velocidade até um relógio - na otimização do processador, em paralelo e quem sabe o que mais funciona no nível dos microcomandos

Qualquer pergunta de novato, Problemas com o Tempo() A recessão global no

Interessante assumir a OLP - página 8