Interessante presa di posizione sull'OLP - pagina 10

Nuovo commento
 
Vitaly Muzichenko:

Non mi piace affatto questo design in termini di leggibilità e disordine

Sono d'accordo)))

L'unica giustificazione per questo è il debug)

 
Vitaly Muzichenko:

Non mi piace affatto questo design in termini di leggibilità e disordine

questa era originariamente la mia domanda

gli ultimi esempi sono l'affermazione di@fxsaber che ci sarà il 100% di codici diversi a runtime. ho postato il disassembler dal debugger un paio di pagine fa - i codici sono al 90% gli stessi

Non sto parlando di non riuscire a restituire semplici costrutti che si leggono senza problemi

 
Igor Makanu:

gli sviluppatori hanno scritto da qualche parte e qui informazioni simili

ha trovato solo questo:

switch è un goto sicuro che usa una tabella di salto. Cioè, l'indirizzo "caso" è calcolato utilizzandouna chiave intera in switch. A causa di questo switch è estremamente efficiente anche rispetto a if-else, per non parlare di collezioni più avanzate come i dizionari.

 
fxsaber:

Questo non ha l'effetto negativo di scrivere qualsiasi codice di qualità con l'aspettativa che "il compilatore lo spazzoli al meglio"?

Con uno stile di scrittura, sai per certo che il compilatore farà la cosa giusta. Con un altro stile devi solo avere fiducia che il compilatore sia più intelligente.

Data la multipiattaforma, i diversi compilatori, ecc, scelgo di essere consapevole di ciò che si sta facendo nel codice.

Solo il compilatore sa esattamente cosa farà. I compilatori di oggi hanno un'euristica sbalorditiva. Si adattano al codificatore medio e sanno già meglio di cosa ha bisogno. La cosa migliore che un compilatore può fare è scrivere codice semplice e diretto con funzioni brevi. È più facile ed efficiente per il compilatore analizzare il grafo del codice sorgente composto da molti nodi di funzione per costruire il programma risultante. Questo può solo avere un impatto positivo sulle prestazioni, dato che le funzioni necessarie sono delineate nei posti giusti.

 
Vasiliy Sokolov:

switch è un goto sicuro che usa una tabella di salto. Cioè, l'indirizzo del 'caso' è calcolato dallachiave intera in switch. Per questo motivo, switch è estremamente efficiente anche rispetto a if-else, per non parlare di collezioni più avanzate come i dizionari.

Forte! Questa è un'informazione utile

Grazie!

 

Molte persone raccomandano di scrivere piccole classi. Lo stesso Eckel dice: "creare classi per un unico scopo chiaramente definito".

Sto lavorando su un EA in questo momento, e scriverò un esempio semplificato. C'è uno dei parametri "Reach max stoploss". Quando si ottiene SL dovrebbe funzionare come contatore di ritorno fino a zero e fermare il lavoro di EA, e quando si ottiene TP dovrebbe ripristinare il valore iniziale, con il valore visualizzato sul pannello.

Ho creato una classe separata per questo contatore. Risulta che cambia da diversi punti, da OnInit quando si impostano i parametri di input e dal campo di input del pannello dopo la chiusura dell'ordine (sl e tp cambiano valore in modo diverso). Inoltre, la funzione principale è chiamata da OnTick() per tenere traccia del numero massimo di stoploss per fermare l'EA.

La classe sembra essere molto semplice. Ma si scopre che questa piccola classe influenza altri oggetti situati nel pannello (casella di input, pulsanti). Influenza il funzionamento di altre funzioni. E quando ci sono una dozzina di queste piccole classi, è già difficile rintracciare quali funzioni cambiano l'oggetto o quali metodi di alcuni oggetti possono cambiare lo stato di altri oggetti.

Voglio sapere come organizzare l'interazione degli oggetti tra loro nel modo migliore per ridurre la confusione, ci sono buoni articoli o libri con esempi di codici, diagrammi su questo argomento e buone spiegazioni? Per favore, condividi ciò che ha aiutato qualcuno a imparare a scrivere architetture ben progettate.

 
Questo non è un problema OOP, ma un problema con l'approccio generale alla creazione degli EA. Dovremmo contare il numero di stoploss in base alla storia. In generale, è a questo che serve la testa di un uomo, non c'è una soluzione universale.
 
Vitaly Muzichenko:

Non mi piace affatto questo design in termini di leggibilità e disordine

Gusto e colore.... tutti i pennarelli sono diversi.

Era un contrasto con il "piccolo mostro":

Forum sul trading, sistemi di trading automatico e test di strategie di trading

Interessante opinione su OOP

fxsaber, 2021.01.31 01:09

Un piccolo mostro.

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

Leoperazioni logiche permettono una scrittura concisa quando si usano diverse impostazioni tramite macro. Ma è un orrore, ovviamente.


 
Andrey Khatimlianskii:

Gusto e colore.... tutti i pennarelli sono diversi.

Non è vero. Variano solo nel colore, ma hanno tutti lo stesso sapore...))))

 
Vitaly Muzichenko:

Non mi piace affatto questo design in termini di leggibilità e disordine

Perché?

Al contrario, con due "se" è molto più facile che con l'operatore "o".

È più facile controllare prima una condizione, e lasciare la funzione se è vera, e poi controllarne un'altra, e lasciare anch'essa, se è vera, piuttosto che cercare di capire quale sia il risultato di una condizione complessa, usando la logica "o" (che può essere facilmente confusa con "e"), e tenere traccia di entrambe le opzioni di ritorno.

È piuttosto divertente leggere qui sotto che "la giustificazione per tale è il debugging", perché significa che tale codice è molto più comprensibile (altrimenti perché è in debugging?).

"Apoteosi" considero un'espressione di fxsaber, sulla quale lui stesso non poteva dire come funziona, affermando semplicemente che "il codice è stato ripetutamente testato, e funziona". Questo, secondo me, non dovrebbe essere il 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);
};

Questo codice controlla seun ordine otfFilingType può essereeseguito, e lo restituisce se è disponibile su strSymbol, altrimenti è corretto.


Non ho assolutamente idea di come funzioni. E fare affidamento solo sull'autorità di fxsaber.

Forse qualcuno può spiegare?

1...345678910111213
Nuovo commento