Exécution des Programmes MQL4

 

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 )

 

{xtypo_code}//——————————————————————–
// 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()
}
//——————————————————————– {/xtypo_code}

 

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 :

{xtypo_code}int Count = 0 ;                     // Global variable {/xtypo_code}

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 :

{xtypo_code} int init ()                                 // Spec. Funct. init ()
{
Alert ( ” Function init() triggered at start ” ) ;     // Alert
return ;                             // Exit init()
}  {/xtypo_code}

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 :

{xtypo_code} int start ()                             // Special funct. int start ()
{
double Price  = Bid ;                 // Local variable
Count ++;  
Alert ( ” New tick ” , Count , ” Price = ” , Price) ;     // Alert
return ;                             // Exit start()
} {/xtypo_code}

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

{xtypo_code}double Price  = Bid ;             // Local variable{/xtypo_code}

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 :

{xtypo_code}Count ++;{/xtypo_code}

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() :

{xtypo_code}Alert ( ” New tick ” , Count , ” Price = ” , Price ) ;             // Alert  {/xtypo_code}

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 :
{xtypo_code}New tick 1 Price = 1.2744{/xtypo_code}

35(1). Opérateur

{xtypo_code} return ;             // Exit start(){/xtypo_code}

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

{xtypo_code}double Price  = Bid ; // Local variable{/xtypo_code}

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 :

{xtypo_code}Count ++;{/xtypo_code}

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() :

{xtypo_code}Alert ( ” New tick ” , Count , ” Price = ” , Price ) ;         // Alert {/xtypo_code}

é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 :
{xtypo_code}New tick 2 Price = 1.2745{/xtypo_code}

35(2). Opérateur
{xtypo_code}return ;                         // Exit start(){/xtypo_code}

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).

{xtypo_code} int deinit ()                                 // Special funct. int deinit ()
{
Alert ( ” Function deinit() triggered at exit ” ) ;     // Alert
return ;                             // Exit deinit()
}{/xtypo_code}

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”

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *

You may use these HTML tags and attributes: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <s> <strike> <strong>