Toute question des nouveaux arrivants sur MQL4 et MQL5, aide et discussion sur les algorithmes et les codes. - page 808
Vous manquez des opportunités de trading :
- Applications de trading gratuites
- Plus de 8 000 signaux à copier
- Actualités économiques pour explorer les marchés financiers
Inscription
Se connecter
Vous acceptez la politique du site Web et les conditions d'utilisation
Si vous n'avez pas de compte, veuillez vous inscrire
J'essaie donc de trouver ce qui me fait défaut, je comprends que personne n'est susceptible de me dire quoi que ce soit gratuitement - le capitalisme, bordel de merde)). Je n'ai rien contre, j'ai juste besoin de comprendre pourquoi les trades s'ouvrent sur chaque bougie dans le sens de l'achat.
Je ne vous répondais pas.
Si vous voulez que vos skis fonctionnent, vous devez au moins imprimer les valeurs des variables qui sont importantes lorsque le signal est reçu et regarder dans le journal pour voir ce qui se passe avec elles.
Il y a une boucle for(int i=0;i<ArrayRange(arr2,0);i++), donc je veux savoir combien de fois ce calcul ArrayRange(arr2,0) est effectué : une fois et la machine se souvient de la valeur, ou à chaque fois que la boucle est exécutée, la valeur est renvoyée par la fonction ArrayRange(arr2,0) ? Exemple :
1ère option.
i=0,i<(valeur retournée), incrémentation, puis
i<(valeur de retour à nouveau), incrément, puis
i<(retourne à nouveau une valeur), incrémentez de cette façon,
2ème variante.
ou, nous retournons une valeur de ce calcul ArrayRange(arr2,0) une fois, laissons-le retourner 5 et la machine se souvient de ce 5 et obtenons le résultat suivant
i=0,i<(valeur retournée)i<5, incrémentation, puis
i<5, incrémenter, alors
i<5, incrémenter - est-ce ainsi que cela fonctionne ?
Je demande pourquoi : si tout se passe par la première variante, alors il est logique d'extraire cette valeur avant la boucle et de la stocker dans une variable, de sorte que le programme ne calcule pas la fonction ArrayRange(arr2,0) à chaque passage de la boucle.
Il y a une boucle for(int i=0;i<ArrayRange(arr2,0);i++), donc je veux savoir combien de fois ce calcul ArrayRange(arr2,0) est effectué : une fois et la machine se souvient de la valeur, ou à chaque fois que la boucle est exécutée, la valeur est renvoyée par la fonction ArrayRange(arr2,0) ? Exemple :
1ère option.
i=0,i<(valeur retournée), incrémentation, puis
i<(valeur de retour à nouveau), incrément, puis
i<(retourne à nouveau une valeur), incrémentez de cette façon,
2ème variante.
ou bien, nous retournons une valeur de ce calcul ArrayRange(arr2,0) une fois, laissons-le retourner 5 et la machine se souvient de ce 5 et obtenons le résultat suivant
i=0,i<(valeur retournée)i<5, incrémentation, puis
i<5, incrémentation, puis
i<5, incrémenter - est-ce ainsi que cela fonctionne ?
Pourquoi je demande : si tout se passe sur la première variante, alors il est logique avant la boucle d'extraire d'abord cette valeur et de la stocker dans une variable, afin qu'à chaque passage de la boucle le programme ne fasse pas la fonction ArrayRange(arr2,0).
dans le cas général - 1er cas.
PS/ Le deuxième point n'est possible que pour les compilateurs "optimisants", qui peuvent comprendre que s'il n'y a pas de ArrayResize à l'intérieur d'une boucle, alors ArrayRange:=const ; je ne suis pas sûr que le compilateur mql creuse déjà aussi profondément dans le code, bien que pour ses fonctions "natives" ce soit théoriquement possible.
PPS/ L'exemple de ArrayRange() n'est pas tout à fait correct, car il n'y aura probablement pas d'appel direct à la fonction, le compilateur doit juste le réduire à la comparaison de i à une variable interne du tableau, car il sait tout sur les tableaux.
dans le cas général - 1ère variante.
PS/ Le deuxième point n'est possible que pour les compilateurs "optimisants", qui peuvent comprendre que s'il n'y a pas de ArrayResize dans la boucle, alors ArrayRange:=const ; je ne suis pas sûr que le compilateur mql creuse déjà aussi profondément dans le code, bien que pour ses fonctions "natives" ce soit théoriquement possible.
PPS/ l'exemple avec ArrayRange() n'est pas tout à fait correct, parce qu'il n'y aura probablement pas d'appel direct à la fonction, le compilateur doit juste le réduire à la comparaison de i avec une variable interne du tableau, parce qu'il sait tout sur les tableaux.
Prenons l'expression5+5*5
la 1ère variante.
i=0,i<(5+5*5), incrémentation, puis
i<(5+5*5), incrémentation, alors
i<(5+5*5), incrémentez de cette façon,
2ème variante.
ou, dans ce cas, le résultat est un retour unique de 5+5*5, qu'ils retournent 30 et la machine se souvient de ce 30-ku, donc nous obtenons les résultats suivants
i=0,i<(valeur retournée) i<30, incrément, suivant (le moteur se souvient automatiquement de 30 parce que je n'ai pas enregistré 30 quelque part)
i<30, incrémenter, puis
i<30, incrément, c'est comme ça que ça marche ?
Je suppose que ce sera la 1ère variante ? 5+5*5 est une expression qui sera évaluée à chaque itération de la boucle. Vous pouvez calculer cette expression avant la boucle et stocker 30 dans une variable et l'introduire dans la boucle, et cela sera plus facile à utiliser pour la machine, à moins qu'elle ne calcule automatiquement ce 30 et le stocke dans sa mémoire.
S'il n'y a pas d'appel de fonction, le compilateur ne peut pas vérifier l'expression booléenne i<5, donc probablement la première option fonctionnera.
Le résultat d'une fonction(ArrayRange) peut être modifié dans une boucle ou une fonction.
Et l'expression constante(5+5*5) sera toujours la même.
Par conséquent, la fonction sera calculée à chaque passage.
Et la valeur de la constante sera substituée dans le code par le compilateur au moment de la compilation.
Le résultat d'une fonction(ArrayRange) peut être modifié dans une boucle ou une fonction.
Et l'expression constante(5+5*5) sera toujours la même.
Par conséquent, la fonction sera calculée à chaque passage.
Et la valeur de la constante sera substituée dans le code par le compilateur au moment de la compilation.
5+5*5 est aussi une expression et elle doit être calculée à chaque passage, quant à la fonction elle est supposée retourner le même résultat, le fait est qu'à chaque passage de la boucle le compilateur va encore calculer à la fois la fonction et l'expression 5+5*5. Ce sera donc la première option - c'est-à-dire que le calcul est effectué à chaque passage de la boucle, il est donc logique de compter cette valeur avant la boucle et de la stocker dans une variable et d'utiliser la variable comme la même valeur statique afin qu'aucun calcul n'ait lieu à chaque passage de la boucle, cela peut finalement
int k=5+5*5;//k=30
for(int i=0;i<k;i++){}
où k est toujours égal à 30 ou
int k=ArrayRange(arr2,0)//k=5
for(int i=0;i<k;i++){}
où k est toujours égal à 5.
5+5*5 est aussi une expression et elle doit être calculée à chaque passage, quant à la fonction elle est supposée retourner le même résultat, nous parlons du fait qu'à chaque passage de la boucle le compilateur comptera toujours à la fois la fonction et l'expression 5+5*5. Donc ce sera la première option - c'est-à-dire que le calcul est fait à chaque passage de la boucle, donc il est logique de calculer cette valeur avant la boucle et de la stocker dans une variable et d'utiliser la variable comme la même valeur statique de sorte qu'il n'y aura pas de calculs à chaque passage de la boucle, cela peut éventuellement
int k=5+5*5;//k=30
for(int i=0;i<k;i++){}
où k est toujours égal à 30 ou
int k=ArrayRange(arr2,0)//k=5
for(int i=0;i<k;i++){}
où k est toujours égal à 5.
Vous pourriez simplement développer la boucle et ne pas créer de variables supplémentaires.
5+5*5 est aussi une expression et doit être calculée à chaque passage, quant à la fonction elle est supposée retourner le même résultat, nous parlons du fait qu'à chaque passage du cycle le compilateur comptera encore à la fois la fonction et l'expression 5+5*5. Il y aura donc la première option - c'est-à-dire que le calcul est fait à chaque passage du cycle, il est donc logique de compter cette valeur avant le cycle et de la stocker dans une variable et d'utiliser la variable comme la même valeur statique de sorte qu'il n'y ait pas de calculs à chaque passage du cycle, cela finit par mo
Le compilateur travaille toujours une fois - au moment de la compilation du texte en code.
(pour autant que je me souvienne, MT4 compile déjà directement en code également).
5+5*5 - c'est une expression avec des constantes, elles n'ont pas besoin d'être recalculées - donc elle ne sera calculée qu'une fois, au moment de la compilation, et le code contiendra le nombre 30
5+5*5+i est une expression avec une variable, et cela sera calculé dans le code à chaque passage comme 30+i
La fonctionArrayRange renvoie une valeur, mais le compilateur ne sait pas quelle sera cette valeur, il va donc substituer l'appel de la fonction dans le code, et à chaque passage (dans le code) la fonction sera appeléeLe compilateur ne travaille qu'une fois - au moment de la compilation du texte en code.
(pour autant que je me souvienne, MT4 compile déjà directement en code)
5+5*5 est une expression avec des constantes, elles n'ont pas besoin d'être recalculées - donc cela ne sera calculé qu'une fois, au moment de la compilation, et dans le code ce sera 30
5+5*5+i est une expression avec une variable, et elle sera calculée dans le code à chaque passage comme 30+i
La fonctionArrayRange renvoie une valeur, mais le compilateur ne sait pas quelle sera cette valeur, il va donc substituer l'appel de la fonction dans le code, et à chaque passage (dans le code) la fonction sera appeléeJe vois. Merci. Ce n'est pas une question sérieuse, bien sûr, mais il y a des subtilités.
Vous pouvez simplement développer la boucle et ne pas créer de variables supplémentaires.
dans mon cas, il y a 2 expressions mathématiques 1ère-ArrayRange(arr2,0) 2ème5+5*5 mon but est de créer des conditions dans lesquelles le compilateur travaillera avec moins de charge
for(int i=0;i<ArrayRange(arr2,0);i++) dans ce cas, la valeur de comparaison est retournée à chaque passage
int k=ArrayRange(arr2,0)//k=5 for(int i=0;i<k;i++){}dans ce cas la valeur de comparaison est retournée 1 fois au lieu de 4, mais une variable est créée, néanmoins la charge est plus faible, surtout quand on parle de milliers ou de millions.
Pouvez-vous nous montrer comment développer une boucle afin de ne pas avoir à créer de variables ?