Interessante assumir a OLP - página 10

Novo comentário
 
Vitaly Muzichenko:

Não gosto nada deste projeto em termos de legibilidade e desordem

Eu concordo))))

A única justificativa para isso é a depuração)

 
Vitaly Muzichenko:

Não gosto nada deste projeto em termos de legibilidade e desordem

essa era originalmente minha pergunta

os últimos exemplos são a declaração de@fxsaber de que haverá códigos 100% diferentes em tempo de execução. eu postei o desassemblador do depurador há algumas páginas atrás - os códigos são 90% iguais

não se trata de não devolver construções simples que lêem sem problemas

 
Igor Makanu:

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

só encontrou isto:

é uma opção segura que utiliza uma mesa de salto. Ou seja, o endereço 'case' é calculado usandouma chave inteira no interruptor. Devido a esta mudança é extremamente eficiente mesmo em comparação com o if-else, para não mencionar coleções mais avançadas como dicionários.

 
fxsaber:

Isto não tem o efeito negativo de escrever qualquer código de qualidade com a expectativa de que "o compilador o escovará ao máximo"?

Com um estilo de escrita, você sabe com certeza que o compilador vai fazer a coisa certa. Com outro estilo você só tem que confiar que o compilador é mais inteligente.

Dada a plataforma cruzada, diferentes compiladores, etc., eu escolho estar ciente do que você está fazendo no código.

Somente o compilador sabe exatamente o que vai fazer. Os compiladores de hoje têm uma eurística impressionante. Eles se adaptam ao codificador médio e já sabem melhor o que ele ou ela precisa. A melhor coisa que um compilador pode fazer é escrever um código simples, direto e com funções curtas. É mais fácil e mais eficiente para o compilador analisar o gráfico do código fonte que consiste de muitos nós de função para construir o programa resultante. Isto só pode ter um impacto positivo no desempenho, uma vez que as funções necessárias estão alinhadas nos lugares certos.

 
Vasiliy Sokolov:

é uma opção segura que utiliza uma mesa de salto. Ou seja, o endereço 'case' é calculado a partir dachave inteira no interruptor. Por causa disso, a troca é extremamente eficiente mesmo em comparação com as coleções if-else, para não mencionar as coleções mais avançadas como os dicionários.

legal! esta é uma informação útil

obrigado!

 

Muitas pessoas recomendam escrever classes pequenas. A mesma Eckel diz: "criar classes para um único e claramente definido propósito".

Estou trabalhando em um EA agora mesmo, e vou escrever um pouco de simplificação para um exemplo. Há um dos parâmetros "Reach max stoploss". Ao obter SL ele deve funcionar como contador de retorno até zero e parar o trabalho da EA, e ao obter TP ele deve ser redefinido para o valor inicial, com o valor exibido no painel.

Eu fiz uma classe separada para este balcão. Acontece que ele muda de vários pontos, do OnInit ao definir os parâmetros de entrada e do campo de entrada do painel após o fechamento do pedido (sl e tp mudam de valor de forma diferente). Além disso, a função principal é chamada da OnTick() para acompanhar o número máximo de paradas para parar a EA.

A classe parece ser muito simples. Mas acontece que esta pequena classe afeta outros objetos localizados no painel (caixa de entrada, botões). Afeta o funcionamento de outras funções. E quando há uma dúzia de classes tão pequenas, já é difícil rastrear quais funções mudam o objeto ou quais métodos de alguns objetos podem mudar o estado de outros objetos.

Quero saber como organizar a interação dos objetos uns com os outros da melhor maneira para reduzir a confusão, existem bons artigos ou livros com exemplos de códigos, diagramas sobre este assunto e boas explicações? Por favor, compartilhe o que ajudou qualquer pessoa a aprender como escrever arquiteturas bem projetadas.

 
Este não é um problema do OOP, mas um problema com a abordagem geral para a criação de EAs. Deveríamos contar o número de paradas por história. Em geral, é para isto que serve a cabeça de um homem, não existe uma solução universal.
 
Vitaly Muzichenko:

Não gosto nada deste projeto em termos de legibilidade e desordem

Sabor e cor.... todas as canetas de feltro são diferentes.

Era um contraste com o "pequeno monstro":

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

Opinião interessante sobre o OOP

fxsaber, 2021.01.31 01:09

Um 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 uma escrita concisa ao utilizar diferentes configurações via macros. Mas é um horror, é claro.


 
Andrey Khatimlianskii:

Sabor e cor.... todas as canetas de feltro são diferentes.

Não é verdade. Só variam na cor, mas todos têm o mesmo sabor...))))

 
Vitaly Muzichenko:

Não gosto nada deste projeto em termos de legibilidade e desordem

Por quê?

Pelo contrário, com dois "se" é muito mais fácil do que com o "ou" operador.

É mais fácil verificar uma condição primeiro, e deixar a função se for verdadeira, e depois verificar outra, e deixar também, se for verdadeira, do que tentar descobrir qual é o resultado de uma condição complexa, usando o "ou" lógico (que pode ser facilmente confundido com "e"), e manter o controle de ambas as opções de retorno.

É muito engraçado ler abaixo que "a justificação para tal é a depuração", porque significa que tal código é muito mais compreensível (caso contrário, por que está na depuração?).

"Apoteose" considero uma expressão do fxsaber, sobre a qual ele mesmo não poderia dizer como funciona, afirmando simplesmente que "o código foi testado repetidamente, e funciona". Isso, em minha opinião, não deveria ser o caso:

ENUM_ORDER_TYPE_FILLING CSymbolInfo::GetTypeFilling(string strSymbol,ENUM_ORDER_TYPE_FILLING otfFilingType)
{
   const ENUM_SYMBOL_TRADE_EXECUTION steExeMode = (ENUM_SYMBOL_TRADE_EXECUTION)::SymbolInfoInteger(strSymbol, SYMBOL_TRADE_EXEMODE);
   const int iFillingMode = (int)::SymbolInfoInteger(strSymbol, SYMBOL_FILLING_MODE);

   return((iFillingMode == 0 || (otfFilingType >= ORDER_FILLING_RETURN) || ((iFillingMode & (otfFilingType + 1)) != otfFilingType + 1)) ?
         (((steExeMode == SYMBOL_TRADE_EXECUTION_EXCHANGE) || (steExeMode == SYMBOL_TRADE_EXECUTION_INSTANT)) ?
           ORDER_FILLING_RETURN : ((iFillingMode == SYMBOL_FILLING_IOC) ? ORDER_FILLING_IOC : ORDER_FILLING_FOK)) :
          otfFilingType);
};

Este código verifica seo pedido do tipo FilingType pode serexecutado e o devolve se estiver disponível no strSymbol, caso contrário está correto.


Não tenho a menor idéia de como funciona. E contar apenas com a autoridade do fxsaber.

Talvez alguém possa explicar ?

1...345678910111213
Novo comentário
Razão: