Opérateurs MQL4

Le terme d’opérateur

Une des notions clés de n’importe quel langage de programmation est le terme d'”opérateur”. Programmer semble être impossible pour une personne ne connaissant pas complètement cette notion. Le plus rapidement le programmeur maitrisera cette notion, le plus rapidement il pourra commencer à écrire ses propres programmes.

Un Opérateur est une partie d’un programme; c’est une phase dans un langage algorithmique qui décrit une certaine méthode de conversion des données.

Tous les programmes contiennent des opérateurs. L’analogie la plus proche d’un opérateur serait une phrase. De la même manière que des phrases composent un texte d’une historie, les opérateurs composent un programme.

Propriétés des opérateurs

Les opérateurs ont deux types de propriété: des propriétés communes et d’autres spécifiques à chaque opérateur.

 

Propriétés communes des opérateurs

Tous les opérateurs ont une propriété en commun; ils sont tous exécutés.

Nous pouvons dire qu’un opérateur est une instruction contenant un guide d’opérations à effectuer. Pour un ordinateur, exécuter un programme (consécutivement passer d’un opérateur à un autre) reviens à se conformer aux instructions contenues dans les opérateurs. Si l’ordinateur exécute les transformations de données spécifiées dans un opérateur, vous pouvez affirmer que l’opérateur a été exécuté.

Un opérateur est seulement une certaine séquence de caractères.

Propriétés spécifiques des opérateurs

 

Il y a plusieurs types d’opérateurs. Les opérateurs de chaque type ont leurs propriétés spécifiques. Par exemple, la propriété d’un opérateur d’assignement est la capacité à assigner une certaine valeur à une variable; la propriété d’une boucle est son exécution multiple, etc. Chaque opérateur possède donc des propriétés personnelles qui le caractérise

 

Types d’opérateurs

Il y a deux types d’opérateur: les opérateur simples et composés.

 

Les opérateurs simples

Les opérateurs simples de MQL4 terminent avec le caractère “;” (point virgule). Grâce à ce séparateur, le PC peut détecter où se termine un opérateur et où un autre commence. Le caractère “;” est nécessaire dans un programme au même titre que le caractère “.” l’est pour séparer des phrases. Un opérateur peut prendre plusieurs lignes et plusieurs opérateurs peuvent être placés sur la même ligne.

{xtypo_warning}Chaque opérateur doit se terminer par le caractère “;” (point virgule).{/xtypo_warning}

 

Exemples d’opérateurs simple :

{xtypo_code}Day_Next= TimeDayOfWeek(Mas_Big[n][0]+60); // Opérateur simple

Go_My_Function_ind(); // Opérateur simple

a=3; b=a*x+n; i++; // Plusieurs opérateurs sur une même ligne

Print( Day= ,TimeDay(Mas_Big[s][0]), // Un opérateur..
Hour=,TimeHour(Mas_Big[s][0]), //est situé..
Minute=,TimeMinute(Mas_Big[s][0]),//sur plusieurs ..
Mas_Big[s][0]= ,Mas_Big[s][0], // lignes
Mas_Big[s][1]= ,Mas_Big[s][1]);{/xtypo_code}

 

Les Opérateurs Composés

Afin de pouvoir utiliser plusieurs opérateurs là où seulement un est attendu, les programmeurs utilisent donc les opérateurs composés. Un opérateur composé est formé de plusieurs opérateurs simples séparés par le caractère “;” et encadrés par des parenthèses.

{xtypo_warning}Un exemple d’utilisation d’un opérateur composé est l’opérateur conditionnel. Il commence par l’opérateur conditionnel if(expression) et est suivi par le composé qui contient une liste des opérateurs à exécuter. {/xtypo_warning}

 

 

 

Fig. 17. Opérateur composé.

 

{xtypo_warning}Le corps d’un opérateur composé est enfermé entre parenthèses. {/xtypo_warning}

 

Exemples d’opérateurs composés:

{xtypo_code}// Exemple d’opérateur switch
switch(ii) // Opérateur switch(expression)
{ // Ouvurture parenthèse
case 1: Buf_1[Pokf+i]= Prognoz; break; // Opérateurs internes (corps de l’opérateur)
case 2: Buf_2[Pokf+i]= Prognoz; break; // Opérateurs internes (corps de l’opérateur)
case 3: Buf_3[Pokf+i]= Prognoz; break; // Opérateurs internes (corps de l’opérateur)
} // Fermeture Parenthèse,..
// .. montre où l’opérateur se termine
//—————————————————–
// Exemple de l’utilisation d’une boucle
for (tt=1; tt<=Kol_Point[7]; tt++) // Opérateur for(expressions)
{ // Parenthèse d’ouverture
Numb = Numb + Y_raz[tt]*X_raz[ii][tt]; // Opérateurs internes (corps de l’opérateur)
} // Fermeture Parenthèse,..
// .. montre où l’opérateur se termine
//—————————————————–
// Exemple de l’opérateur conditionnel if
if (TimeDay(Mas_Big[f][0])!= 6) // if (expression)
{ // Parenthèse d’ouverture
Sred =(Nabor_Koef[ii][vv][2]+ NBh)*Point;// Opérateurs internes (corps de l’opérateur)
Ind = Nabor_Koef[ii][vv][0] + f; // Opérateurs internes (corps de l’opérateur)
Print( Ind= ,Ind); // Opérateurs internes (corps de l’opérateur)
} // Fermeture Parenthèse,..
// .. montre où l’opérateur se termine{/xtypo_code}

 

{xtypo_alert}Le corps d’un opérateur composé est toujours enfermé entre des parenthèses et peut être constitué de zéro ou plusieurs opérateurs{/xtypo_alert}

 

Exemples d’opérateurs simples :

{xtypo_code}//———————————————–
// Exemple d’opérateur for
for (n=1; n<=Numb; n++) // for(expressions)
Mas[n]= Const_1+ n*Pi; // Opérateur interne (corps de l’opérateur)
//———————————————————-
// Exemple de l’opérateur conditionnel if
if (Table > Chair) // if (expression)
Norma = true; // premier opérateur (suboperateur 1)
else // condition Ekse (sinon)
Norma = false; // second opérateur (subopérateur 2)
//———————————————————{/xtypo_code}

 

{xtypo_alert}Plusieurs opérateurs peuvent être combinés en un opérateur composé sans que cela soit strictement nécessaire.{/xtypo_alert}

 

C’est rare, mais c’est une construction complètement admissible. Dans ce cas, les opérateurs enfermés dans les parenthèses sont appelés “bloc d’opérateurs”. C’est le programmeur qui décide s’il souhaite ou non enfermer ses opérateurs dans des parenthèses pour des soucis de présentation du code. Un exemple de bloc d’opérateur :

 

{xtypo_code}{ // Parenthèse Ouvrante
Day_Next= TimeDayOfWeek(Mas_Big[n][0]+60); // Opérateur Simple
b=a*x+n; // Opérateur Simple
} // Parenthèse fermante{/xtypo_code}

 

Prérequis des Opérateurs

Les opérateurs doivent être écrits dans le code d’un programme en respectant des règles de format (comment ils doivent être représentés dans un code). Aucun opérateur ne peut être composé en dehors de ces règles. La conséquence du non respect de ces règles sera l’apparition de messages d’erreurs dans le MetaEditeur à la compilation. Le programme ne pourra alors pas être exécuté.

Vous devriez comprendre la phrase “format de l’opérateur” comme un ensemble de règles de format typiques  à l’opérateur donné. Ces règles seront vues plus en détail dans la section appropriée du livre.

Ordre d’Exécution des Opérateurs

Une importante caractéristique de tout programme est l’odre d’exécution des opérateurs qui le compose. Les opérateurs ne peuvent pas être exécutés sans raison ou par exception. En MLQ4, l’ordre d’exécution suivant des opérateurs est accepté :

 

{xtypo_alert}Les opérateurs sont exécutés dans l’ordre dans lequel ils apparaissent dans le programme. La direction de l’exécution des opérateurs va de gauche à droite et de haut en bas, tout comme le sens de lecture classique.{/xtypo_alert}

 

Ecriture et Exécution des Opérateurs: Exemples

Le code d’un programme contenant des opérateurs ressemble en aspect à un texte normal ou à des notations mathématiques. Cependant cette similarité est seulement formelle. Un texte normal. Cependant, cette similarité n’est que formelle. Dans un texte normal, les notes peuvent êtres placées dans n’importe quel ordre, alors que pour un programme, un ordre spécifique est à respecter.

Voyons voire avec un exemple comment fonctionne un opérateur d’assignement. Nous résoudrons un simple système d’équation linéaire et nous comparerons la représentation des calculs scientifiques dans un texte normal et dans le code d’un programme.

Problème 7 : Voici le système d’équation:
Y = 5
Y – X = 2
Nous recherchons la valeur de la variable X

Solution 1. Sur une feuille de papier classique:

1. 5 – ? = 2

2. ? = 5 – 2

3. ? = 3

Solution 2. Dans un programme:

Y = 5; // Ligne 1
X = Y2; // Ligne 2

 

Les deux solutions ont un contenu similaire et amènent au résultat. Néanmoins, il n’est pas possible d’utiliser la solution 1 dans un programme car les formats des lignes ne respectent pas le format de l’opérateur d’assignement.

Les notes données en solution 1 peuvent informer le programmeur des relations qu’il y a entre les variables. Mais les opérateurs sont utilisés dans un autre objectif. Ils informent à la machine quelles opérations effectuer et dans quel ordre. Tous les opérateurs sans exceptions représentent des instructions précises qui ne laissent pas de place à des ambiguïtés.

Les 2 opérateurs de la Solution 2 sont des opérateurs d’assignement. Tous les opérateurs d’assignement donne l’ordre suivant à l’ordinateur :

{xtypo_alert}Calculer la valeur d’une expression à la droite du signe d’égalité et assigner sa valeur à la variable à la gauche du signe d’égalité.{/xtypo_alert}

 

C’est pour cette raison que seulement des variables peuvent être placées à la gauche de l’opérateur d’assignement. Par exemple, une ligne de code  5 – ? = 2 utilisée dans la première solution provoquera une erreur car 5 – X n’est pas une variable.

Suivons les opérations exécutées par l’ordinateur pour la seconde solution :

1. Passer à l’opérateur de la ligne 1.

Y = 5; // Ligne 1

2. Référencement à la partie droite de l’opérateur (entre le signe d’égalité et le point virgule).

3. L’ordinateur a détecté que la partie droite de l’opérateur contiens une valeur numérique.

4. Enregistrement de la valeur numérique (5) dans la cellule mémoire de la variable Y.

5. Passage à l’opérateur suivant (ligne 2).

X = Y2; // Ligne 2

6. Référencement à la partie droite de l’opérateur.

7. L’ordinateur a détecté que la partie droite de l’opérateur contiens une expression.

8. Calcule de la valeur numérique de la partie droite de l’opérateur (5 – 2).

9. Enregistrement de la valeur numérique 3 dans la cellule mémoire de la variable X.

 

La réalisation par l’ordinateur des étapes 1  à 4 correspond à l’opérateur de la ligne 1, et celle des ligne 5 à 9 à l’opérateur de la ligne 2.

Afin de coder un programme fonctionnel, le programmeur doit bien réaliser ce que doit faire un programme et dans quel ordre. En particulier, tous les calculs mathématiques ne seront pas mis dans le programme.

Par exemple, de nombreux calculs intermédiaires sont faits lorsque l’on résous un problème mathématique. Ils peuvent aider un mathématiciens à trouver une solution propre, mais s’avèrent inutiles du point de vue de la programmation. Seuls les calculs indispensables doit être menés comme par exemple fixer la valeur initiale de certaines variables pour en calculer d’autres. Dans l’exemple précédant, le premier opérateur porte l’information de la valeur numérique de la variable Y, tandis que le second opérateur apporte la formule pour calculer la variable X qui nous intéresse.

Tous les programmes fonctionnels contiennent des expressions familières, mais vous pouvez aussi trouver des expressions que vous ne pourrez comprendre qu’en tant qu’opérateurs. Par exemple, considérez la ligne de code ci dessous :

X = X + 1; // Exemple de compteur

Cette ligne semble fausse d’un point de vue logique. Toutefois, c’est tout à fait acceptable si vous le considérez en tant qu’opérateur. C’est d’ailleurs un opérateur largement utilisé en programmation.

Dans cet opérateur, nous calculons une nouvelle valeur de la variable X: lorsque l’on exécute l’opérateur d’assignement, l’ordinateur commence par calculer la valeur de l’expression numérique située à droite du signe d’égalité. Il commence donc à chercher en mémoire de l’ordinateur la valeur courante de la variable X (prenons 3) puis réalise l’opération de calcule (3 + 1) et écris son résultat (4) dans la cellule mémoire de la variable de gauche, c’est à dire X. Le résultat de cet opération est donc l’incrémentation de une unité de la variable X.

 

Retour sommaire.

Traduction: Nicolas Vitale
Source: http://book.mql4.com/basics/operators
“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>