Aiutami a imparare a programmare. - pagina 4
Ti stai perdendo delle opportunità di trading:
- App di trading gratuite
- Oltre 8.000 segnali per il copy trading
- Notizie economiche per esplorare i mercati finanziari
Registrazione
Accedi
Accetti la politica del sito e le condizioni d’uso
Se non hai un account, registrati
Dmitry Fedoseev:
Ricalcola ogni volta, o non ricalcola
Non hai capito niente. Il mondo non si è fermato con PositionTotal(). Sto solo sottolineando che è sbagliato farlo.
Dmitry Fedoseev:
Ma invece di portare un esperimento killer
Cosa non ti piace del mio esperimento? Il compilatore ha sovraottimizzato il risultato della prima chiamata?
Questo è esattamente ciò che ottimizza: for (int i = 0; i < 1+2 ; i++) {}
o questo: const int X = 1 ;per (int i = 0; i < X+2; i++) {}
ma questo non è sicuramente: int X = 1 ; for (int i = 0; i < X+1; i++) {} perché non sono un telepate e non so cosa e dove può succedere a questo X - può essere modificato all'interno del ciclo o indirettamente, per esempio, da un link/pointer? Farà l'addizione 'X+1' per ogni iterazione. Anche se rimuovete '+1', il programma userà ancora il valore corrente di 'X', a meno che questo 'X' non sia dichiarato come una costante.
E certamente non cache il risultato restituito dalla funzione, Karl! (anticipando il tuo "what if for (int index=f();)") - c'è solo una chiamata qui, all'inizializzazione dell'indice).
Dmitry Fedoseev:
E il compilatore - volevo dire che ottimizza il codice e chiama la variabile direttamente, non attraverso una funzione
Sì, certo, il compilatore conosce esattamente la situazione sul mercato ed è sicuro che una chiamata di funzione restituisce sempre lo stesso valore, quindi perché chiamare questa funzione più di una volta a tutti, basta ricordare il risultato in OnInit() una volta e OK!
E non si preoccupa che anche all'interno dell'esecuzione del ciclo stesso, nel tuo caso con PositionsTotal(), alcuni ordini possono essere già andati - fermati, chiusi dalle mani o da un altro EA - e il resto non sarà processato perché tutti improvvisamente! hanno ottenuto meno?
Dmitry Fedoseev:
Questo è chiaramente visibile con la funzione ArraySize(); non si può dire la differenza tra chiamare la funzione e usare una variabile. Ma non è così con PositionsTotsl(), ahimè.
Come si relazionano la dimensione di una matrice e il numero di posizioni attualmente aperte? State accedendo agli elementi dell'array tramite un indice, bene, per esempio, accedete all'array[999] con una dimensione di 3 elementi. Se questo array è effettivamente un tipo 'intelligente', una classe lì per esempio con operatore '[]' dove viene eseguito il controllo di validità, allora va bene. Ma se non lo fosse? Comunque, questo è un classico esempio di shithcode. Perché dovremmo gassificare la pozzanghera, basta ammetterlo e non preoccuparsi.
Dmitry Fedoseev:
Ricalcola ogni volta, o non ricalcola
Non hai capito niente. Il mondo non è venuto a capo di PositionTotal(). Sto solo sottolineando che è sbagliato farlo.
Dmitry Fedoseev:
Ma invece di portare un esperimento killer
Cosa non ti piace del mio esperimento? Il compilatore ha sovraottimizzato il risultato della prima chiamata?
Questo è esattamente ciò che ottimizza: for (int i = 0; i = 1+2; i++) {}
o questo: const int X = 1 ;per (int i = 0; i = X+2; i++) {}
questo è esattamente no: int X = 1 ; for (int i = 0; i = X+1; i++) {} perché non sono un telepate e non so cosa e dove può succedere a questo X - può essere modificato all'interno del ciclo o indirettamente da un riferimento/pointer, per esempio? Farà l'addizione 'X+1' per ogni iterazione. Anche se rimuovete '+1', il programma userà ancora il valore corrente di 'X', a meno che questo 'X' non sia dichiarato come una costante.
E certamente non cache il risultato restituito dalla funzione, Karl! (anticipando il tuo "ma cosa succede se per (int index=f();)") - c'è solo una chiamata qui, all'inizializzazione dell'indice).
Dmitry Fedoseev:
E il compilatore - volevo dire che ottimizza il codice e chiama la variabile direttamente, non attraverso una funzione
Sì, certo, il compilatore conosce esattamente la situazione sul mercato ed è sicuro che una chiamata di funzione restituisce sempre lo stesso valore, quindi perché chiamare questa funzione più di una volta a tutti, basta ricordare il risultato in OnInit() una volta e OK!
E non si preoccupa del fatto che anche all'interno dell'esecuzione del ciclo stesso, nel tuo caso con PositionsTotal(), alcuni ordini possono essere già andati - fermati, chiusi dalle mani o da un altro EA - e il resto non sarà processato perché tutti improvvisamente! hanno ottenuto meno?
Dmitry Fedoseev:
Questo è chiaramente visibile con la funzione ArraySize(), non si può dire la differenza tra chiamare la funzione e usare una variabile. Ma non è così con PositionsTotsl(), ahimè.
Come si relazionano la dimensione di una matrice e il numero di posizioni attualmente aperte? State accedendo agli elementi dell'array tramite un indice, bene, per esempio, accedete all'array[999] con una dimensione di 3 elementi. Se questo array è effettivamente un tipo 'intelligente', una classe lì per esempio con operatore '[]' dove viene eseguito il controllo di validità, allora va bene. Ma se non lo fosse? Comunque, questo è un classico esempio di shithcode. È meglio non cercare di gassificare la situazione.
Se non c'è una fine in vista a PositionTotal(), avete mancato del tutto l'obiettivo. Perché la funzione ArraySize() può essere chiamata ad ogni ripetizione del ciclo, e la velocità non cambia.
Non sono soddisfatto del tuo esperimento a causa della sua assenza.
Tutte le altre vostre fantasie non sono interessanti perché sono fantasie (e inoltre sono selvagge e molto lontane dalla realtà e persino false).
Dovresti essere all'asilo.
Con la consapevolezza di cosa? Se è un algoritmo che non esiste in natura, ma devi inventarlo tu, e definisce tutto.
Con la conoscenza di come scrivere con competenza il codice giusto nella lingua di interesse.
Non capisco, non esiste un algoritmo che possa fare questo?
Infatti, l'autore ha creato l'argomento con questa domanda.
E i cicli e le prestazioni delle funzioni sono stati discussi da altri. Ma sono anche quelli che vogliono conoscere il modo migliore o il modo giusto.
Con la conoscenza di come scrivere il codice giusto con competenza nella lingua di interesse.
Non capisco, non c'è un algoritmo che possa farlo?
Così l'autore ha creato l'argomento con questa domanda in mente.
E per quanto riguarda i loop e le prestazioni delle funzioni altre persone erano interessate. Per così dire, più sofisticati nella realizzazione di tali algoritmi) Ma anche loro sono quelli che vogliono sapere come farlo meglio o come farlo bene.
E quindi sei ancora su come calcolare le posizioni? Beh, allora mi dispiace.
Interessanti questi sofisticati, che vogliono ancora sapere... e ancora non sanno. E tutto questo riguarda anche il calcolo delle posizioni?
Scusa ancora, non mi sbaglio, con la frase "implementazione dell'algoritmo" intendi una funzione di conteggio delle posizioni? Cioè, se scrivete PositionsTots() in un ciclo o usate una variabile - lo chiamate algoritmo?E quindi state ancora parlando di come contare le posizioni? Beh, mi dispiace allora.
Interessanti questi sofisticati che vogliono ancora sapere... e ancora non sanno. E si tratta anche di contare le posizioni?
Quindi di cosa state discutendo se la domanda è esaurita)? LOL.
C'è un compito per ottenere i dati di posizione.
C'è una funzione di lingua per ottenere il numero di posizioni aperte, che viene utilizzata nel ciclo.
C'è una questione di come usarlo correttamente nel ciclo: nel primo parametro del ciclo for o nel secondo - dove viene controllata la condizione.
È strano che tu non capisca cosa vuoi)))
Lei scrive che è costoso perché il numero non è costante. Ma perché, non si può spiegare.
Può spiegare perché è costoso?
Personalmente penso che gli sviluppatori si siano assicurati che questa funzione non ricalcolasse le posizioni aperte ogni tick, e che lo facesse solo quando apriva e chiudeva una posizione.
Pensate che gli sviluppatori non ci abbiano pensato?
Come puoi essere così sicuro che la funzione è costosa e ricalcola, e non prende semplicemente il valore dalla memoria del terminale?
Finora, invece di una risposta sostanziale, ho letto chiacchiere inutili.
Allora di cosa state discutendo se la questione è finita)? LOL.
Questo è l'umorismo della situazione - per le seconde ventiquattro ore a pagina quattro un simposio su come contare le posizioni. Molto interessante.
Se PositionTotal() non è l'unica cosa che conta, allora avete perso il punto. Perché la funzione ArraySize() può essere chiamata ad ogni ripetizione del ciclo, e la velocità non cambia.
Non sono soddisfatto del tuo esperimento a causa della sua assenza.
Tutte le altre vostre fantasie non sono interessanti, perché sono fantasie (e inoltre sono selvagge e molto lontane dalla realtà, e anche false).
ArraySize(), se un array non è dinamico o di un tipo di classe, è già una costante quando si dichiara l'array stesso. Ma non significa ancora nulla, perché ArraySize(array) e sizeof(array) sono due grandi differenze. Il primo viene chiamato ma non lo si vede; il secondo viene calcolato in fase di compilazione.
Quindi dite il vostro punto di vista alternativo da un'altra parte.
-----------------
Perché sto cercando di spiegarmi? Una persona non vuole vedere e pensare. Molto bene, lasciagli generare un codice il cui funzionamento dipende dalla fase lunare, dal tempo medio del meridiano di Marte e dal prurito del tallone posteriore sinistro. L'unico peccato è che molte persone, specialmente i novizi, copiano il codice *nuovo* nei loro progetti senza pensarci due volte e poi si scervellano su cosa sia sbagliato.
ArraySize(), se l'array non è dinamico e non è di tipo classe, è già una costante quando si dichiara l'array stesso. Ma anche questo non significa nulla, perché ArraySize(array) e sizeof(array) sono due grandi differenze. Il primo viene chiamato ma non lo si vede; il secondo viene calcolato in fase di compilazione.
Perciò dite il vostro punto di vista alternativo da un'altra parte.
-----------------
Perché sto cercando di spiegarmi? Una persona non vuole vedere e pensare. Molto bene, lasciagli generare un codice il cui funzionamento dipende dalla fase lunare, dal tempo medio del meridiano di Marte e dal prurito del tallone posteriore sinistro. L'unico peccato è che molte persone, specialmente i novizi, non ci pensano nemmeno due volte a copiare codice *nuovo* nei loro progetti e poi si scervellano su cosa sia sbagliato.
Questo è un argomento che uccide! Nessuna parola... Perché dovreste applicare ArraySize() a un array non dinamico? Non riesco a immaginare come si possa pensare una cosa del genere. E cosa c'entra la sizeof()? Tutto bene lì?
E questo non è il mio punto di vista, ma uno che è stato a lungo verificato dai partecipanti al forum. Ma non cercherò questo thread.
Ma posso dirvi che non ha niente a che fare con il caching.
Per me, penso che sia un bene che una persona cerchi di capire e scavi più a fondo...
Non prestando attenzione alle piccole cose, il programmatore prende l'abitudine di scrivere il codice nel modo sbagliato. E poi pettinare il codice significa doppio lavoro e spesso non solo per l'autore ma per chi ha ancora la fortuna di lavorare con il codice.
Perché preoccuparsi di scrivere codice quando si può farlo correttamente e scriverlo bene e capire i dettagli?)
Il tuo consiglio è... beh... IMHO
Il tuo consiglio è buono per un programmatore esperto (molto fiducioso) che può poi pettinarlo, perché sa dove e cosa deve essere pettinato.
Fedoseyev ha ragione. Non è necessario, e ci vorrà un po' di tempo per pettinare il codice come vorreste. Ma con il tempo si capisce che è meglio scrivere qualcosa di nuovo. Così ogni nuovo codice sarà pettinato all'inizio.
Interessanti realtà del forum. Quando qualcuno chiede qualcosa, nessuno scriverà una riga di codice. Ma appena lo fanno, vengono, si mettono in fila e cominciano a battere - ah, ah, ah, che codice sbagliato. E ciò che è interessante, di solito riguarda il codice semplice come tre copechi. Ogni spazio è sotto esame. Per qualcosa di più complicato, c'è il silenzio, sordo come un carro armato.