|
MQL4
|
Sortie en boutique ce mois ci du livre de Henry Baltzer intitulé "Programmer en MQL4". Henry avait déjà écrit en format électronique le fameux "MQL4 pour les nuls". Face à la demande et à l'abscence de toute offre francophone, il a décidé d'amméliorer ce premier jet et de produire un livre complet au format papier. Le livre étant publié à compte d'auteur, acheter une version est aussi un moyen de supporter ce genre d'inititatives plus que rares puisque c'est la première...
Apprenez à automatiser vos stratégies sur MetaTrader 4. Cet ouvrage est le premier guide de programmation en
MQL4 en français. Grâce à ce manuel, vous pourrez apprendre à programmer vos stratégies, modifier des codes existants ou encore tout simplement comprendre la logique derrière certains experts consultants.
Programmer en MQL4 est dispoinible en boutique de Trading Automatique.
|
|
|
Réalise par Jeremy et Alexandre de l'équipe de Trading Automatique.
|
|
Voici les slides et l'enregistrement du webinaire que j'ai realise sous l'invitation d'ActivTrades : "comment elaborer efficacement ses EAs".
Telechargez les transparents
|
|
Les compétences en programmation seront mieux développées si le programmeur a un programme léger à sa disposition. Pour comprendre l'ensemble du programme, il est nécessaire d'examiner complètement tous ses composants et de tracer son fonctionnement pas à pas.
Veuillez noter que les propriétés des fonctions spéciales des différents programmes d'application (Expert Advisors, scripts, indicateurs) sont différentes.
Maintenant, nous allons analyser comment fonctionne un EA.
Exemple d'un simple EA ( simple.mq4 )
//--------------------------------------------------------------------
// simple.mq4
// Pour être utilisé comme exemple dans le livre de
MQL4.
//--------------------------------------------------------------------
int Count = 0 ; // Global variable
//--------------------------------------------------------------------
int init () // Spec. Funct. init ()
{
Alert ( " Function init() triggered at start " ) ; // Alert
return ; // Exit init()
}
//--------------------------------------------------------------------
int start () // Spec. funct. start()
{
double Price = Bid ; // Local variable
Count ++; // Tick counter
Alert ( " New tick " , Count , " Price = " , Price ) ; // Alert
return ; // Exit start()
}
//--------------------------------------------------------------------
int deinit () // Spec. funct. deinit()
{
Alert ( "Function deinit() triggered at deinitialization " ) ; // Alert
return ; // Exit deinit()
}
//--------------------------------------------------------------------
1. 1. Au moment où un programme est joint à un graphique, le Terminal Client passe le contrôle au programme et ensuite le programme va commencer son exécution.
L'exécution du programme commence à partir de l'entête.
L'entête ne contient qu'une seule ligne :
int Count = 0 ; // Global variable
Dans cette ligne, la variable globale "Count" est déclarée et initialisée à 0.
(Les variables locales et globales sont analysées en détail dans la section Types de Variables . Il convient de noter ici, que l'algorithme utilisé dans ce programme d'exemple exige la déclaration de la variable Count comme globale, c'est pourquoi elle ne peut être déclarée dans une fonction, elle doit être déclarée en dehors de la description des fonctions, c'est à dire dans l'entête ; de sorte que la valeur de la variable globale Count sera disponible à partir de n'importe quelle partie du programme.)
2. 2. Après l'exécution de l'entête du programme, la fonction spéciale init() sera lancée pour l'exécution.
Veuillez noter que cet appel de fonction n'est pas contenu dans un code de programme.
Le début de l'exécution de init() lorsque un EA est joint à un graphique est la propriété spécifique de la fonction.
Le Terminal Client fera appel à init() pour exécution simplement parce que le code du programme contient sa description.
Dans le programme analysé, la description de la fonction spéciale init() est la suivante :
int init () // Spec. Funct. init ()
{
Alert ( " Function init() triggered at start " ) ; // Alert
return ; // Exit init()
}
Le corps de la fonction ne contient que deux opérateurs.
2.1 La fonction Alert() montre une fenêtre d'information :
Fonction init() déclenchée au début
2.2 L'opérateur termine l'opération de la fonction spéciale init()
À la suite de l'exécution de init(), un message d'information sera produit.
Dans les programmes réellement utilisés, un tel algorithme est très rare, parce que l'utilisation de ce init() n'est pas d'une grande utilitée. Vraiment, il n'y a pas de sens à utiliser une fonction qui indique à un opérateur qu'il est en cours d'exécution. Ici l'algorithme est utilisé uniquement pour la visualisation de l'exécution de init().
Attention: la fonction spéciale init() est exécutée une seule fois dans un programme. L'exécution de la fonction a lieu au début du fonctionnement du programme, après qu'un entête ait été traité. Quand l'opérateur return est exécuté dans la fonction spéciale init(), le programme renvoie le contrôle au Terminal Client.
3. Le Terminal Client détecte la description de la fonction spéciale start() dans le programme :
int start () // Special funct. int start ()
{
double Price = Bid ; // Local variable
Count ++;
Alert ( " New tick " , Count , " Price = " , Price) ; // Alert
return ; // Exit start()
}
3.1. Le contrôle est tenu par le terminal client.
Le Terminal Client attend un nouveau tick et ne démarre pas les fonctions du programme tant qu'un nouveau tick n'arrive pas.
Cela signifie que le programme ne fonctionne pas pendant un certain temps, c'est à dire pas d'actions réalisées par lui. Une pause apparaît, bien qu'il n'y ait ni commande directe ou indirecte pour effectuer cette pause.
La nécessité d'attendre un tick est la propriété spécifique de start() et il n'existe aucun moyen pour influencer cette propriété (par exemple, de le désactiver).
Le programme sera en attente pour le contrôle jusqu'à ce qu'un nouveau tick arrive.
Quand un nouveau tick arrive, le Terminal Client passe le contrôle au programme, à savoir à la fonction spéciale start() (dans ce cas, conformément à la propriété de la fonction start() de l'EA).
À la suite son exécution démarre.
3.2 (1). Dans la ligne
double Price = Bid ; // Local variable
les actions suivantes sont effectuées :
32.1(1). Déclaration d'une variable locale Price (voir types de variables).
La valeur de ces variables locales seront disponibles à partir de n'importe quelle partie de la fonction spéciale start().
32.2(1). Exécution de l'opérateur d'affectation.
La valeur actuelle du prix offert sera affectée à la variable Price.
Le nouveau prix de valeur apparaît chaque fois qu'un nouveau tick arrive (par exemple, au premier tick un prix de titre égal à 1.2744).
33(1). Puis la ligne suivante est exécutée :
Count ++;
Cette façon inhabituelle d'écrire signifie Count = Count +1; (analogie au langage C)
Au moment de passer le contrôle de cette ligne, la valeur de la variable Count est égal à zéro. À la suite de l'exécution Count++, la valeur de la variable Count sera augmentée de un. Ainsi, au moment de passer le contrôle à la ligne suivante, la valeur de Count sera égale à 1.
34(1). La ligne suivante contient l'appel à la fonction Alert() :
Alert ( " New tick " , Count , " Price = " , Price ) ; // Alert
La fonction va écrire toutes les constantes et les variables énumérées entre les parenthèses.
À la première exécution de la fonction start(), le programme va écrire New tick, puis se réfère-vous à la variable Count pour obtenir sa valeur (à la première exécution cette valeur est égale à 1), écrit cette valeur, puis écrit Price = et se refère à la variable Price pour obtenir sa valeur (dans notre exemple, il est 1,2744) et lécrire.
En conséquence, la ligne suivante sera écrite :
New tick 1 Price = 1.2744
35(1). Opérateur
return ; // Exit start()
termine l'opération de la fonction spéciale start().
36. Le contrôle est retourné au Terminal Client (jusqu'à ce qu'un nouveau tick arrive).
Voilà comment la fonction start() d'un EA est exécuté.
Lorsque l'exécution est terminée, la fonction spéciale start() retourne le contrôle au Terminal Client et quand un nouveau tick arrive, le Terminal Client démarre son fonctionnement une fois de plus.
Ce processus (à partir de l'exécution de la fonction start() et renvoi du contrôle au Terminal Client) peut se poursuivre pendant une longue période - plusieurs jours ou semaines. Pendant tout ce temps la fonction spéciale start() sera exécutée de temps à autre.
En fonction des paramètres d'environnement (nouveaux prix, le temps, les conditions de trading, etc) dans la fonction spéciale start(), différentes actions comme ouvrir ou modifier les ordres peuvent être effectuées.
37. A partir du moment de la réception d'un nouveau tick, les actions des points 32-36 sont répétés.
Toutefois, seule la séquence des opérateurs exécutés se répète, mais les variables seront affectées des nouvelles valeurs à chaque fois. Voyons les différences entre la première et la deuxième exécution de la fonction spéciale start().
32(2). Dans la ligne
double Price = Bid ; // Local variable
les actions suivantes sont effectuées :
32.1(2). Déclaration d'une variable locale Price (inchangé).
32.2(2). Exécution de l'opérateur d'affectation.
La valeur actuelle du prix Bid sera affectée à la variable Price (une nouvelle valeur de cotation apparaît chaque fois qu'un nouveau tick arrive, par exemple au deuxième tick le prix du titre sera égal à 1,2745) (il ya des changements).
33(2). Puis la ligne suivante sera exécutée :
Count ++;
Au moment de passer le contrôle de cette ligne, la valeur de la variable Count (après la première exécution de la fonction start()) est égal à 1.
À la suite de l'exécution de Count++, la valeur de Count sera augmentée de un.
Ainsi, lors de la deuxième exécution, Count sera égal à 2 (modifié).
34 (2). Fonction Alert() :
Alert ( " New tick " , Count , " Price = " , Price ) ; // Alert
écrit toutes les constantes et variables (les nouvelles valeurs) énumérées entre parenthèses.
A la deuxième exécution de start() le programme va écrire New tick, puis se réfère à la variable Count pour obtenir sa valeur (en deuxième exécution, elle est égale à 2), écrire cette valeur, puis écrire Price = et indiquer la variable Price, obtenir sa valeur (dans notre exemple 1,2745) et l'écrire (modifiée).
En conséquence, la ligne suivante sera écrite :
New tick 2 Price = 1.2745
35(2). Opérateur
return ; // Exit start()
termine l'opération de la fonction start() (sans changement).
36(2). Le contrôle est retourné au terminal client pour attendre un nouveau tick.
37 (2). Puis c'est répété à nouveau.
Dans la troisième exécution start() les variables auront de nouvelles valeurs et seront écrites par la fonction Alert(), c'est à dire le programme reprend les points 32-36 (3).
Et puis ainsi de suite : 32 - 36 (4), 32 - 36 (5 ),..( 6) .. (7) .. (8) ...
Si un utilisateur n'effectue aucune action, ce processus sera répété à l'infini.
À la suite de l'opération start() dans ce programme, nous allons voir l'historique du changement des prix des ticks.
Les événements suivants se reproduiront tant que l'utilisateur n'aura pas décidé de mettre fin au programme en forçant manuellement le programme à sortir du graphique.
4. Le Terminal Client passe le contrôle à la fonction spéciale deinit() (conformément à ses propriétés).
int deinit () // Special funct. int deinit ()
{
Alert ( " Function deinit() triggered at exit " ) ; // Alert
return ; // Exit deinit()
}
Il n'ya que deux opérateurs dans le corps de la fonction.
41. Alert() écrira :
Fonction deinit() déclenchée à la sortie
42. Opérateur return termine le fonctionnement de deinit().
La fonction deinit() est lancée pour l'exécution par le terminal client une seule fois, après que Alert() ci-dessus apparaîsse dans la fenêtre d'information et le programme sera supprimé du graphique.
5. Ici se termine l'exécution des EA.
Insérez cet exemple de programme pour n'importe quel graphique et le lancer.
Le programme d'exploitation affiche une fenêtre contenant toutes les alertes générées par la fonction Alert(). Par le contenu de la fenêtre des alertes, il est facile de comprendre quelle fonction spéciale est liée à telle ou telle entrée.
Fig. 35. Résultats d'exploitation du programme simple.mq4 .
Dans cet exemple, vous pouvez facilement voir que le programme est exécuté conformément aux propriétés des fonctions spéciales décrites dans Fonctions Spéciales.
Terminer le programme et le relancer.
Après avoir essayé plusieurs fois, vous obtiendrez l'expérience du fonctionnement d'un programme MQL4. D'autres programmes que vous écrivez vous-même seront également construits en conformité avec la structure décrite et pour le démarrage de leur exécution, vous devrez également le joindre à un graphique.
Comprendre tous les concepts, les règles et les processus de création de programmes en MQL4 sera alors facile et agréable.
Retour sommaire cours MQL4
Traduction: Jean Marc Venet
Source: http://book.mql4.com/programm/execution
"MQL4 is a trade mark of MetaQuotes Software Corp. and all related materials are reserved for MetaQuotes"
|
|
Fonctions spéciales
La particularité des programmes destinés à fonctionner dans le Terminal Client
MT4 est leur interaction avec des informations constamment mises à jour en mode temps réel.
Dans le langage
MQL4, cette particularité se reflète sous la forme de trois fonctions spéciales: init (), start () et deinit ().
Les fonctions spéciales sont des fonctions avec des noms prédéfinis init(), start() et deinit() possédant des propriétés particulières spécifiques.
Propriétés des fonctions spéciales
Propriété commune des fonctions spéciales
La principale propriété de l'ensemble des fonctions spéciales est leur exécution dans un programme sous certaines conditions, sans l'aide d'appel de fonction spéciale du programme. Les fonctions spéciales sont appelées à être exécutées par le Terminal Client. Si un programme contient la description d'une fonction spéciale, il sera appelé (et exécuté), conformément aux conditions d'appel (propriétés spécifiques).
Les fonctions spéciales sont appelées à être exécutées par le Terminal Client.
Propriétés spécifiques des fonctions spéciales
Fonction spéciale init().
La propriété spécifique de la fonction spéciale init() est son exécution à l'initialisation du programme. Si un programme contient la description de la fonction spéciale init(), elle sera appelée (et exécutée) au lancement du programme. S'il n'ya pas de fonction spéciale init() dans un programme, aucune action ne sera effectuée au lancement du programme.
Dans les Expert Advisors (EA), la fonction spéciale init() est appelée (et exécutée) après le démarrage du Terminal Client et le téléchargement des données historiques, après avoir changé de titre et/ou la période du graphique, après la recompilation du programme dans MetaEditor, après avoir changé les paramètres d'entrée dans la fenêtre de configuration des EA et après changement du compte.
Dans les scripts, la fonction spéciale init() est aussi appelée (et exécutée) immédiatement après qu' il soit appliqué à un graphique.
Dans les indicateurs personnalisés, la fonction spéciale init() est appelée (et exécutée) immédiatement après le démarrage du Terminal Client, après avoir changé de titre et/ou la période du graphique, après la recompilation du programme dans MetaEditor et après avoir changé les paramètres d'entrée dans la fenêtre de configuration de l'indicateur personnalisé.
Fonction spéciale start().
Les propriétés spécifiques de la fonction spéciale start() diffèrent selon le type de programme exécutable. Dans les EA, la fonction spéciale start() est appelée (et exécutée) immédiatement après l'arrivée d'une nouvelle cotation.
Si une nouvelle cotation arrive durant l'exécution de la fonction spéciale start(), cette cotation sera ignorée, càd que la fonction spéciale start() ne sera pas appelée pour exécution lorsqu'une telle cotation survient.
Toutes les cotations reçues au cours de l'exécution de la fonction spéciale start() seront ignorées.
Le démarrage de la fonction spéciale start() pour exécution n'est assurée par le Terminal Client qu'à la condition que la session de la précédente opération ait été effectuée, le contrôle étant retourné au Terminal Client et la fonction spéciale start() est en attente d'une nouvelle cotation.
La possibilité d'appeler et d'exécuter la fonction spéciale start() est influencée par l'état du bouton "Activer / désactiver les EA". Si ce bouton est dans l'état de désactivation des EA, le Terminal Client n'appellera pas pour exécution la fonction spéciale start() indépendamment du fait que de nouvelles cotations arrivent ou non. Toutefois, le changement de l'état -activé à désactivé- du bouton ne met pas fin à la session de fonctionnement courante de la fonction spéciale start().
La fonction spéciale start() n'est pas appelée par le Terminal Client si la fenêtre des propriétés des EA est ouverte. La fenêtre des propriétés des EA ne peut être ouverte que lorsque la fonction spéciale start() est en attente d'une nouvelle cotation. Cette fenêtre ne peut pas être ouverte durant l'exécution d'une session de la fonction spéciale start() des EA.
Dans les scripts, la fonction spéciale start() est appelée (et exécutée) immédiatement après l'initialisation du programme dans la fonction spéciale init ().
Dans les indicateurs personnalisés la fonction spéciale start() est appelée (et exécutée) immédiatement après qu'une nouvelle cotation survienne, immédiatement après avoir été attachée à un graphique, lors du changement de taille de la fenêtre du titre, lors du passage d'un titre à l'autre, lors du démarrage du Terminal Client (si au cours de la session précédente un indicateur a été fixé à un graphique), après avoir changé un symbole et la période d'un graphique en cours, indépendamment du fait de savoir si de nouvelles cotations surviennent ou non.
La fin d'une session courante d'exécution de start() pour tous les types de programmes peut être réalisée quand un programme est retiré d'un graphique, où le titre et/ou la période de graphique sont modifiés, quand un compte est modifié / un graphique est fermé et à la suite de fin d'opération du terminal client.
Si la fonction spéciale start() a été exécutée au cours de la commande de fermeture, le temps disponible pour le terminal pour achever l'exécution de la fonction est de 2,5 secondes.
Si après la commande de fermeture, la fonction spéciale start() poursuit son opération plus longtemps que le délai indiqué, elle sera forcée à l'arrêt par le Terminal Client.
Fonctions spéciale deinit().
La fonction spécifique de la fonction spéciale deinit() est son exécution à la fin du programme (terminaison).
Si un programme contient la description de la fonction spéciale deinit(), elle sera appelée (et exécutée) à la fermeture du programme.
Si un programme ne contient pas cette fonction spéciale deinit(), aucune action ne sera réalisée lors de l'arrêt du programme.
La fonction spéciale deinit() est également appelée pour exécution par le Terminal Client à la fermeture du terminal, quand une fenêtre de titre est fermée, juste avant de changer de titre et/ou la période du graphique, à une recompilation réussie du programme dans MetaEditor, lors de la modification des paramètres d'entrée , ainsi que quand le compte est modifié.
Dans les EA et les scripts, l'arrêt du programme avec l'appel nécessaire de la fonction spéciale deinit() peut se produire lors de l'attachement d'un graphique à un nouveau programme du même type qui remplace le précédent. Dans les indicateurs personnalisés la fonction spéciale deinit() n'est pas exécutée quand un nouvel indicateur est joint à un graphique.
Plusieurs indicateurs peuvent fonctionner sur chaque fenêtre spécifique à un sous-jaccent particulier, c'est pourquoi la fixation d'un nouvel indicateur à un graphique n'entraîne pas la fermeture d'autres indicateurs avec l'appel à deinit().
Le temps d'exécution de deinit() est limité à 2,5 secondes.
Si le code de la fonction spéciale deinit() est exécuté plus longtemps, le Terminal Client forcera la fin de l'exécution de la fonction spéciale deinit() et le fonctionnement du programme.
Exigences pour les fonctions spéciales
Les fonctions spéciales init() et deinit() peuvent être absentent dans un programme. L'ordonnancement des descriptions des fonctions spéciales dans un programme n'a pas d'importance. Les fonctions spéciales peuvent être appelées depuis n'importe quelle partie du programme, conformément à l'ordonnancement général des appels de fonction.
Les fonctions spéciales peuvent intégrer des paramètres. Cependant, lorsque ces fonctions sont appelées par le Terminal Client, aucun paramètre ne sera envoyé de l'extérieur, les valeurs par défaut étant seulement utilisées.
Les fonctions spéciales init() et deinit() doivent terminer leur fonctionnement le plus rapidement possible et en aucun cas fonctionner dans une voie essayant de démarrer l'opération complète avant d'appeler la fonction spéciale start().
Ordre d'utilisation des fonctions spéciales
Les développeurs ont présenté aux programmeurs un outil très pratique : lors du démarrage d'un programme, tout d'abord init() est exécuté, après cela la principale tâche est effectuée avec l'aide de la fonction start(), et quand un utilisateur termine son travail, le fonction deinit() sera lancée avant l'arrêt du programme.
Le code principal d'un programme doit être contenu dans la fonction start().
Tous les opérateurs, et les appels des fonctions intégrées et personnalisées et tous les calculs nécessaires devront être effectuées à l'intérieur de cette fonction.
Dans le même temps, il faut bien comprendre le rôle des fonctions personnalisées.
La description des fonctions personnalisées est située dans un code de programme en dehors de la description des fonctions spéciales, mais si une fonction personnalisée est appelée pour exécution, une fonction spéciale ne termine pas son opération. Cela signifie que le contrôle est passé de temps en temps à la fonction personnalisée, mais la fonction personnalisée opère elle-même au sein d'une fonction spéciale qui l'a appelée.
Ainsi, dans le processus de l'exécution du programme la fonction spéciale fonctionne toujours (conformément à leurs propriétés spécifiques) et la fonction personnalisée, sont exécutées lorsqu'elles sont appelées par des fonctions spéciales.
Si un programmeur n' pas l'intention d'utiliser les fonctions spéciales, il peut refuser de les utiliser dans un programme. Dans un tel cas, le terminal client ne l'appellera pas. Dans l'absolu, un programme normal contient l'ensemble des trois fonctions spéciales. Un programme qui n'a pas init() ou deinit() ou ces deux fonctions est également considéré comme normal. Si aucune des fonctions spéciales n'est utilisée dans un programme, ce programme ne sera pas exécuté.
Le Terminal Client n'appelle pour exécution, que les fonctions spéciales en fonction de leurs propriétés.
Les fonctions personnalisées ne sont pas appelées par le terminal client. C'est pourquoi si un programme ne contient pas de fonctions spéciales (et ne contient que des fonctions personnalisées), il ne sera jamais appelé pour exécution.
Il n'est pas recommandé d'appeler la fonction start() à partir de la fonction spéciale init() ou effectuer des opérations de trading à partir de la fonction init(), car au cours de l'initialisation des valeurs d'information de l'environnement, les paramètres peuvent ne pas être prêts (information sur les graphiques, les prix du marché, etc.)
Les articles Exécution de programme et les Exemples de mise en œuvre, contiennent plusieurs exemples pratiques qui permettront de voir les propriétés des fonctions spéciales.
Retour sommaire cours MQL4
Traduction: Jean Marc Venet
Source: http://book.mql4.com/programm/special
"MQL4 is a trade mark of MetaQuotes Software Corp. and all related materials are reserved for MetaQuotes"
|
|
|
|
|
<< Début < Précédent 1 2 3 4 5 6 Suivant > Fin >>
|
|
Page 1 sur 6 |
|
