Les fonctions en MQL4

 

Le Terme de Fonction

L’avancée la plus importante dans le domaine du génie logicielle est la possibilité de créer et stocker des fragments de code séparé qui décrivent les règles de la manipulation des données pour résoudre des problèmes relatifs à des petites tâches. Une telle possibilité existe aussi en MQL4.

Une Fonction est une partie spécifique du programme qui décrit une méthode de manipulation des données. 

En parlant des fonctions, nous considèrerons deux aspects: la description de la fonction et son appel.

La description de la fonction est une partie spécifique du programme dont le but est d’être exécuté.

Un appel de fonction (référence à une fonction) est un fragment de code qui aboutit a l’exécution d’une fonction.

Dans notre vie de tous les jours, nous pouvons trouver beaucoup d’analogies avec les fonctions. Prenons par exemple le système de freinage d’une voiture. Le mécanisme réel qui réalise cette tache respectant l’idée de l’ingénieur est analogue à une fonction tandis que la pédale de frein est analogue à l’appel de la fonction. Le conducteur appuie sur la pédale de frein qui met en action le mécanisme de freinage aboutissant à l’arrêt de la voiture.

De même, si un appel de fonction survient dans un programme, la fonction du même nom sera appelée et exécutée, c’est à dire qu’une certaine séquence de calculs ou d’autres actions seront réalisées (par exemple l’affichage d’un message ou l’ouverture d’un ordre, etc). Le sens général d’une fonction est dans la prise d’un morceau de code externe à la partie du code exécuté, tandis que l’appel de la fonction se fait dans la partie du code exécuté. Une telle construction des programmes a des avantages incontestables :

  • premièrement, le code du programme produit est beaucoup plus lisible;
  • deuxièmement, on peut facilement voire te modifier si nécessaire le code d’une fonction sans modifier le code du programme;
  • enfin, une fonction peut être composée d’un fichier unique et être utilisée dans d’autres programmes, ce qui facilitera la tache du programmeur qui n’aura pas besoin d’insérer les lignes de code de la fonction dans chacun de ses programmes;

On peut affirmer que la plus grande partie du code des programmes écrits en MQL4 le sont sous forme de fonction. L’approche utilisant les fonctions s’est vite répandue et est désormais un standard.

Composition d’une Fonction

Une fonction peut donc être décrite et appelée. Prenons un exemple. Supposons que nous avons un petit programme (Fig. 18) qui trouve la longueur de l’hypoténuse en utilisant les deux autres côtés du triangle rectangle et le théorème de Pythagore.

{xtypo_alert}Dans ce programme, tous les calculs sont réalisés ensemble et les opérateurs sont exécutés dans l’ordre un par un dans l’ordre dans lequel ils apparaissent dans le programme (de haut en bas). {/xtypo_alert}

 

 

Fig. 18. Le code du petit programme pitagor.mq4.
 

Problème 8 : Réalisez une partie du programme donné en fonction.

Il serait raisonnable de réaliser une fonction qui reprenne les deux lignes permettant de calculer la valeur. Le programme équivalent est montré dans la Fig 19.

Dans ce programme, une partie des calculs est réalisée partir d’une fonction. Le code de base contient un appel à une fonction définie par l’utilisateur. La description de la fonction définie par l’utilisateur est située en dehors du code basique.

 

Fig. 19. Le code du programme qui contiens la description et l’appel de la fonction gipo.mq4.
 

Les deux versions du programme donneront les mêmes résultats. Cependant, le code est composé d’un seul module dans la première version (Fig. 18), tandis que dans la seconde version (Fig. 19) une partie des calculs est exécutée dans la fonction appelée par le code principal. Une fois que les calculs de la fonction sont terminés, le code principale continue de s’exécuter.

Afin d’exécuter la fonction, nous devons l’appeler. C’est pourquoi la fonction est représentée en pratique en deux parties: le code en lui même composant la fonction (description de la fonction) et son appel utilisé pour lancer la fonction (référence à la fonction). Si vous n’appelez pas la fonction, elle ne sera jamais exécutée. Au même moment, si vous appelez une fonction qui n’existe pas, cela provoquera une erreur à la compilation.

Description de la Fonction

La description de la fonction est composée de deux parties : l’en-tête (header) et le corps (body).

Le header (en-tête) d’une fonction consiste à indiquer le type qui est retourné par la fonction, le nom de la fonction et la liste des paramètres que prend la fonction en argument. La liste des paramètres sont placés entre parenthèses après le nom de la fonction. Le type de la valeur retournée par la fonction peut être un des types que nous connaissons déjà:  int, double, bool, color, datetime, ou string. Si la fonction ne retourne pas de valeur, son type peut être noté comme “void” ce qui signifie “vide”, ou alors comme n’importe quel autre type.

Le body (corps) de la fonction est contenue entre accolade “{” et “}”. Le corps de la fonction peut contenir des opérateurs simples et/ou composés ainsi que des appels à n’importe quelle fonction (y compris elle même). La valeur retournée par la fonction est donnée entre les parenthèses de  l’opérateur return(). Le type de la valeur retournée utilisant l’opérateur return(), doit correspondre avec le type retourné par la fonction et déclaré dans l’en tête de la fonction. Il ne faut pas oublier de fermer l’accolade de fin de fonction.

 

 

 

Fig. 20. Description de Fonction.

{xtypo_alert}La description de la fonction doit être placée séparément dans le code du programme, en dehors notamment de toute autre fonction.{/xtypo_alert}

 

Appel de Fonction

L’appel de Fonction fait référence au nom de la fonction et à la liste des paramètres transférés. Cette liste de paramètre est placée entre parenthèses. L’appel à la fonction peut être vu comme un opérateur en tant que tel ou une partie d’un opérateur.

 

 

Fig. 21. Appel de fonction (référence à une fonction)

 

{xtypo_alert}Un appel de fonction est toujours réalisé à l’intérieure d’une autre fonction. {/xtypo_alert}

 

Types de Fonction

Il y a trois types de fonction: les fonctions spéciales, standards (prédéfinies) et les fonctions définies par les utilisateurs.

 

Les Fonctions Spéciales

En MLQ4, il y a au total trois types de fonctions spéciales. Elles ont des noms prédéfinies: init(), start(), et deinit() qui ne peuvent pas être utilisés pour d’autres fonctions. Ces fonctions seront vues plus en détail dans un chapitre suivant. Ici, il suffit de savoir que le code principale du programme est situé à l’intérieure de ces fonctions (Fig. 18, 19).

La caractéristique des fonctions spéciales est d’être appelées par le terminal client. Bien que ces fonctions ont toutes les propriétés des fonctions classiques, elles ne sont pas appelées par d’autres fonctions si le programme est bien codé.

 

Les Fonctions Standards

MQL4 possède de nombreuses fonctions utiles qui n’ont pas besoin d’être décrite lorsque l’on écrit un programme. Par exemple, calculer des racines carrées ou écrire un message dans les logs ou à l’écran sont des fonctions prédéfinies. L’utilisateur n’a pas besoin d’apprendre le contenu de ces fonctions. Il doit seulement savoir ce que ces fonctions codés par des professionnels produisent comme résultat. 

La caractéristique spéciale des fonctions standards est qu’elles ne sont pas décrites dans le code du programme. Les fonctions standards sont appelées dans le programme de la même manière que lorsque l’on utilise d’autres fonctions.

Dans notre exemple (Fig. 18, 19), deux fonctions standards sont utilisées MathSqrt() et Alert(). La première permets de calculer une racine carrée tandis que la deuxième permets d’écrire un message entre parenthèses à l’écran. Les propriétés des fonctions standards, encore appelées fonction prédéfinies, seront vues plus en détail dans un chapitre suivant.

 

Les Fonctions Définies par les Utilisateurs

Dans certains cas, les programmeurs créent et utilisent leurs propres fonctions. Les fonctions définies par les utilisateurs sont utilisées dans les programmes avec à la fois la description et l’appel de la fonction.

Table 1. Description et appel de fonction pour les différents types de fonction.

Type de Fonction Description Fonction Appel Fonction
Spéciale Applicable Non applicable (*)
Standard Non applicable Applicable
Définie par l’utilisateur Applicable Applicable

 

(*) Bien que les fonctions spéciales peuvent être techniquement appelée par un programme, il n’est pas recommandé de le faire.

 

Propriétés des Fonctions

Exécution de Fonction

La propriété principale de toutes les fonctions est qu’elles sont exécutées lorsqu’elles sont appelées. Les fonctions sont exécutées dans le respect de leur code.

 

Paramètres passés et valeur retournée

Du point de vue de l’information reçue et retournée, une fonction est comme une calculatrice standard. Vous pouvez taper (en utilisant son clavier) une certaine expression constituée de plusieurs valeurs entrées les unes après les autres. Et vous obtiendrez une valeur comme réponse. Une fonction peut obtenir et traiter un ou plusieurs paramètres de programme qui a appelé l’exécution de cette fonction. La fonction terminera ses opérations en renvoyant un paramètre comme réponse au programme.

Les paramètres passés sont spécifiés entre parenthèses après le nom de la fonction appelée. Les paramètres sont séparés par des virgules. Le nombre de paramètre passés à la fonction ne peut excéder 64. La fonction n’a pas forcément besoin de paramètres pour ses calculs. Dans ce cas on passe une liste vide de paramètre en ouvrant et fermant immédiatement les parenthèses situées après le nom de la fonction.

Le nombre, les types et l’ordre des paramètres transmis à la fonction durant son appel doivent correspondre à ceux spécifiés dans la description de la fonction. Dans le cas contraire, le compilateur du MetaEditeur provoquera une erreur. Les constantes, variables, expressions et tableaux peuvent être utilisés comme des paramètres passés en argument.

La valeur de retour est spécifiée entre les parenthèses de l’opérateur return(). Le type de la valeur retournée doit correspondre au type de la fonction donné dans l’en-tête de sa description. Si une fonction ne retourne pas de valeur, rien n’est spécifié dans les parenthèses de l’opérateur return().

Dans notre exemple, les paramètres passés sont les variables A et B (Fig. 21), tandis que la valeur de retour est la variable c (Fig. 20). La nécessité de faire correspondre les types des paramètres entre l’appel et la définition de la fonction est montrée dans la Fig. 22. 

{xtypo_alert}Le nombre, les types et l’ordre des paramètres passés dans l’appel de la fonction doivent correspondre à ceux spécifiés dans la description de la fonction. seulement des variables peuvent être utilisées dans le header des fonctions comme paramètre. {/xtypo_alert}

 

 

 

Fig. 22. Correspondances entre l’appel et la description de la fonction

 

 

Fig. 23. Correspondances entre l’appel et la description de la fonction

 

Paramètres Formels

Un point important des fonctions est l’utilisation des paramètres formels.

Les paramètres formels sont une liste de variables spécifiés dans l’en-tête (header) de la description d’une fonction.

Nous avons mentionné auparavant qu’une fonction pouvait être utilisée dans plusieurs programmes. Cependant, différents programmes utilisent des noms différents pour les variables. Si les fonctions avaient besoin d’une correspondance stricte entre les noms des variables utilisés pour la description et l’appel des fonctions, ce ne serait pas pratique pour le programmeur. Cependant, par chance, les variables utilisées à l’intérieur du code des fonctions n’ont pas de relations avec les variables utilisées dans le programme.

Regardons à nouveau les Fig. 20 et 21. Il devrait être noté que les noms des paramètres passés (A et B sont donnés dans les parenthèses de l’appel de la fonction) ne correspondent pas aux noms des paramètres (a et b) spécifiés dans la description de la fonction. Nous avons remarqué dans la section Constantes et Variables que MQL4 est sensible à la casse. Les noms A, a, B et b sont donc des noms de variable différent. Cependant, il n’y a pas d’erreurs dans ce code.

Les variables (paramètres formels) utilisés dans la description de la fonction ne sont pas liés aux variables utilisées dans le code basique du programme. Ce sont juste des variables différentes. Seulement des variables et non des constantes peuvent être spécifiées dans le header d’une fonction.

Comment ça marche

  • Dans le programme, il survient l’appel à une fonction, les variables A et B étant spécifiées entre parenthèses.
  • Le programme appelle la fonction du même nom qui a des paramètres formels a et b spécifié dans on header.
  • La valeur de la variable A est assignée à la variable a.
  • La valeur de la variable B est assignée à la variable b.
  • La fonction exécutable réalise les calculs en utilisant les valeurs des variables a et b.

 

Ilest permis d’utiliser n’importe quel nom de variables pur les paramètres formes (qui ne coïncident pas avec le nom de variables utilisées dans le programme). Dans cet exemple, nous utilisions les identifiants des paramètres formels a et b. Cependant, nous aurions pu utiliser n’importe quel autre nom comme par exemple  m et n, ou Kat_1 et Kat_2. Bien entendu, lorsque l’on écrit un programme, on devrait spécifier dans le corps de la fonction les calculs qui utilisent les variables spécifiés dans le header. Puisque nous avons déclaré les variables a et b dans l’en-tête, ce sont a et b et non b et n que l’on doit utiliser dans la fonction.

Dans une fonction, les calculs qui sont menés impliquent les paramètres formels a et b mais pas les variables A et B. Toutes les actions menées sur ces variables  a et b (dont les changements de valeur) n’ont aucun effet effet sur les variables  A et B.

La valeur de retour calculée dans la fonction est donnée entre parenthèses dans l’opérateur return(). La valeur d’une variable, le résultat d’une expression ou une constante peut être utilisée comme valeur de retour. Dans notre cas, c’est la valeur de la variable locale c. Une variable locale est une variable déclarée dans une fonction. Si l’on sort de cette fonction, toutes les valeurs des variables locales seront perdues. Les variables locales seront vues plus précisément dans une prochaine section. La fonction retourne dans le programme la valeur de la variable locale c (Fig. 19). Cele signifie que cette valeur sera maintenant assignée à la variable C.

 

Exemple:  Fonctions Standards dans un  Programme

Avant tout, considérons le comportement du programme montré dans la Fig. 18. Nous devrions noter que le code entier du programme est situé dans la fonction start(). A ce niveau de notre apprentissage, nous ne prêteront pas trop d’attention à cela.

Suivons l’exécution du démarrage du programme avec l’opérateur d’assignement :

int A = 3; // Premier coté

1. La partie droite de l’opérateur d’assignement contient la constante spécifiée, sa valeur étant 3.

2. La valeur de 3 (la valeur de la partie de droite) est assignée à la variable A qui se situe à la gauche du symbole d’assignement. 

Le contrôle est donné à la ligne suivante :

int B = 4; // Second coté

3. La partie droite de l’opérateur d’assignement contient la constante spécifiée, sa valeur étant 4.

4. La valeur 4 est assignée à la variable B.

Le contrôle est donné à la ligne suivante :

int C_2 = A*A + B*B; // Somme des carrés des cotés

5. Calcul de la partie droite de l’opérateur d’assignement. Le résultat de ces calculs est la valeur 25. 

6. Assignement de la valeur 25 à la variable C_2.

La ligne suivante représente un opérateur d’assignement dont la partie droite réalise un appel à une fonction standard :

int C = MathSqrt( C_2); // Calcul de l’hypoténuse

Le programme cherche à exécuter l’opérateur d’assignement. Dans cet objectif, il exécute en premier les calculs situés à la droite du signe d’égalité.

7. Le programme appelle l’exécution de la fonction standard MathSqrt() (qui calcule les racines carrées). La valeur de la variable C_2 (dans notre cas cette valeur est égale à 25) sera utilisée comme un paramètre passé à la fonction. Notez qu’il n’y a pas de description de cette fonction standard dans le programme. Il est facile de visulaliser les appels aux fonctions car ils sont colorés par le MetaEditeur en bleu foncé (le programmeur peut d’ailleurs configurer ses propres couleurs).

8. Les calculs sont réalisé dans la fonction standard MathSqrt().

9. La fonction standard MathSqrt() a terminé ses calculs. Elle retourne la valeur obtenue. Dans notre cas, c’est la valeur 5 (la racine carrée def 25).

La valeur retournée par la fonction est maintenant le contenu de ce code :

MathSqrt( C_2)

Ce morceau de codfe peut être désormais considéré comme une variable spéciale, complexe, une “chose” dans laquelle des calculs sont réalisés. Une fois les calculs terminés, cette “chose” prends une valeur. Cette valeur retournée par une fonction peut être assignée à une variable ou utilisée dans d’autres calculs.

10. Dans ce cas, notre valeur est la valeur à la droite du signe d’assignement. En continuant l’exécution de l’opérateur d’assignement, le programme assignera la valeur 5 à la variable C.

11. La prochaine ligne  contiens l’opérateur qui fait référence à la fonction standard Alert() (appel de fonction).

Alert(“Hypotenuse = , C); // Message à l’écran

La fonction standard Alert() ouvre une boîte de dialogue où les valeurs apssées en paramètres sont affichées. Dans ce cas, la fonction a pris deux valeurs comme paramètres :

– la valeur de la chaîne de caractères: Hypoténuse =

– la valeur de la variable entière C: 5

Il était noté au dessus que toutes les fonctions ne doivent pas retourner de valeur. C’est le cas de la fonction standard Alert() qui a une autre tâche qui consiste à afficher un texte à l’écran.

Comme résultat de l’exécution de la fonction Alert(), on obtient dans une fenêtre la ligne suivante :

Hypoténuse = 5 

12. Le dernier opérateur de ce programme termine le travaille de la fonction spéciale start().

return; // Opérateur de sortie de fonction

Le travail du programme est alors terminé.

Une question pourrait vous venir à l’esprit. Comment peut on savoir si une fonction standard retourne une valeur et si oui, de quel type? La réponse est simple. Afin d’obtenir une description détaillée de chaque fonction standard, il est nécessaire de lire la documentation de la MQL4.community, qui est le site lancé par  MetaQuotes Software Corp., ou bien l’aide fournie par le MetaEditor.

 

Exemple: fonction définie par l’utilisateur

Considérons comment le même calcul est réalisé dans un programme contenant un fonction définie par l’utilisateur (Fig. 19). Une certaine partie du code qui qui pouvait être trouvée précédemment dans la fonction spéciale start() est désormais indisponible. Elle est remplacée par l’appel d’une fonction définie par l’utilisateur. Cependant la fonction spéciale start est suivie de la description de la fonction définie par l’utilisateur.

Les deux premières lignes dans lesquelles les variables A et B prennent leur valeur numérique, restent les mêmes. Par conséquent rien ne change dans leur exécution.

int A = 3; // Premier coté
int B = 4; // Second coté

Dans la troisième ligne, nous avons l’opérateur d’assignement. Sa partie droite contiens l’appel à la fonction définie par l’utilisateur :

int C = Gipo(A,B); // Calcule de l’hypoténuse

6. En exécutant cet opérateur, le programme commencera par appeler la fonction définie par l’utilisateur.

Note: La description de la fonction définie par l’utilisateur doit être présente dans votre programme et placée immédiatement après l’accolade qui ferme la fonction spéciale start() (c’est à dire en dehors de la fonction spéciale start()).

A propos de la fonction définie par l’utilisateur, le programme réalisera les opérations suivantes :

6.1. Appel de la variable A afin d’obtenir sa valeur (dans notre cas, 3)

6.2. Appel de la variable B afin d’obtenir sa valeur (dans notre cas, 4)

Note: Dès que le programme commence à appeler la fonction définie par l’utilisateur (mais c’est aussi valable pour les autres fonctions), le programme obtiens juste une copie des valeurs des variables passées en paramètres, tandis que les valeurs de ces variables elle mêmes (dans ce cas A et B) ne sont pas sensées changer (et ne changent pas) suite à l’exécution de la fonction définie par l’utilisateur. 

7. Le contrôle est passé à la fonction définie par l’utilisateur.

Durant le temps complet de l’exécution de la fonction définie par l’utilisateur (sans se préoccuper de sa durée), les valeurs des variables du programme appelant ne seront pas perdues mais gardées en mémoire.

La première ligne dans la description de la fonction définie par l’utilisateur est son header :

int Gipo(int a, int b) // fonction définie par l’utilisateur

En exécutant la fonction définie par l’utilisateur, le programme fera les opérations suivantes :

7.1. La valeur 3 (la première valeur dans la liste des paramètres passés) sera assignée à la variable a (la première valeur dans la liste des paramètres passés).

7.2. La valeur 4 (la deuxième valeur dans la liste des paramètres passés) sera assignée à la variable b (la deuxième valeur dans la liste des paramètres passés).

Ensuite le contrôle sera passé au corps de la fonction pour qu’il puisse exécuter son algorithme.

Le premier opérateur du corps de la fonction est :

int c2 = a*a + b*b; // Somme des carrés des cotés

7.3. En exécutant cet opérateur, le programme calcule la valeur de la partie droite de l’opérateur d’assignement, et après ça il assignera la valeur obtenue (dans notre cas 3*3 + 4*4 = 25) à la variable c2.

Le prochain opérateur:

int c = MathSqrt(c2); // Hypoténuse

7.4. Ici nous trouvons la racine carrée de la valeur de la variable c2. L’ordre des opérations est le même que dans l’exemple précédent. La description des fonctions standards n’est pas utilisée ici. L’exécution de l’opérateur d’assignement aboutira à placer la valeur 5 à la variable c.

7.5. Dans la ligne suivant, nous avons l’opérateur :

return(c); // Opérateur de sortie de fonction

En exécutant cet opérateur, le programme retournera la valeur située dans ses parenthèses. Dans notre cas, c’est la valeur de la variable c, c’est à dire 5.

Désormais, l’exécution de la fonction définie par l’utilisateur est terminée et le contrôle est rendu au point de l’appel.

8. Rappelez vous que la fonction définie par l’utilisateur était appelée par l’opérateur :

int C = Gipo(A,B); // Hypoténuse calcul

Le morceau de code (appel de la fonction) au moment de retourner la valeur, prends la valeur calculée dans la fonction(dansn notre cas 5).

Gipo(A,B)

En terminant l’exécution de l’opérateur d’assignement, le programme assignera la valeur 5 à la variable C.

9. Le prochain opérateur,

Alert(“Hypotenuse = , C); // Message à l’écran,

sera exécuté de la même manière que l’exemple précédent. Dans une fenêtre spéciale apparaitra le message suivant:

Hypoténuse = 5

10. Le dernier opérateur dans ce programme termine le travail de la fonction start() :

return; // Opérateur de sortie de fonction,

Considérons quelques versions différentes de l’implémentation de la fonction définie par l’utilisateur. Il est facile de vérifier que programmer avec de telles fonctions est un réel avantage.

 

Implémentation d’une fonction définie par l’utilisateur Gipo()

Dans cette fonction, les paramètres formels “ressemblent” aux variables utilisées dans le programme basique. Cependant ce n’est qu’une familiarité parce que A et a sont des noms de variable différents.

{xtypo_code}//———————————————————————–
int Gipo(int a, int b) // Fonction définie par l’utilisateur
{
int c2 = a*a + b*b; // Somme des carrés des cotés
int c = MathSqrt(c2); // Hypoténuse
return(c); // Opérateur de sortie de fonction
}
//———————————————————————–
{/xtypo_code}

Implémentation d’une fonction définie par l’utilisateur Gipo(): Version 2

Dans ce cas, les noms des paramètres formels ne “ressemblent” pas aux noms des variables utilisées dans le programme basique. Cependant, ceci nous empêche pas d’utiliser cette fonction dans le programme.

{xtypo_code}//——————————————————————–
int Gipo(int alpha, int betta) // Fonction définie par l’utilisateur
{
int SQRT = alpha*alpha + betta*betta; // Somme des carrés des cotés
int GIP = MathSqrt(SQRT); // Hypoténuse
return(GIP); // Opérateur de sortie de fonction
}
//——————————————————————–
{/xtypo_code}

Implémentation d’une fonction définie par l’utilisateur Gipo(): Version 3

Dans cet exemple, la variable alpha est réutilisée dans le programme et change sa valeur à deux reprises. Ceci n’a pas d’effet sur les variables spécifiées dans les appels des fonctions du programme principale.

{xtypo_code}//——————————————————————–
int Gipo(int alpha, int betta) // Fonction définie par l’utilisateur
{
alpha= alpha*alpha + betta*betta; // Somme des carrés des cotés
alpha= MathSqrt(alpha); // Hypoténuse
return(alpha); // Opérateur de sortie de fonction
}
//——————————————————————–{/xtypo_code}

 

Implémentation d’une fonction définie par l’utilisateur Gipo(): Version 4

Dans cette fonction définie par l’utilisateur, tous les calculs sont rassemblés dans un seul opérateur. La valeur de retour est calculée directement dans les parenthèses de l’opérateur return(). Le calcul sous dupliqué est réalisé directement dans les parenthèses à destination des paramètres de la fonction standard MathSqrt(). La solution peut paraître étrange ou fausse au début. Il n’y a cependant pas d’erreurs dans cette implémentation de fonction définie par l’utilisateur. le nombre d’opérateurs utilisés dans les fonctions est plus petit que dans les autres implémentations, donc le code est plus compact.

{xtypo_code}//——————————————————————–
int Gipo(int a, int b) // Fonction définie par l’utilisateur
{
return(MathSqrt(a*a + b*b)); // Opérateur de sortie de fonction
}
//——————————————————————–
{/xtypo_code}

L’utilisation des fonctions définies par l’utilisateur a donc des avantages incontestables dans la pratique de la programmation :

  • le nom des variables dans le code basique du programme n’a pas de relations avec le nom des paramètres formels spécifiés dans la définition del a fonction.
  • les fonctions peuvent être réutilisées dans différents programmes et il n’est pas nécessaire de changer le code.
  • si nécessaire des librairies peuvent être crées.

 

Ces propriétés très utiles des fonction permettent de créer des programmes de tailles importantes. Par exemple plusieurs programmeurs peuvent travailler en même temps  et n’ont pas besoin de se mettre d’accord entre eux sur les noms des variables à utiliser dans les fonctions. La seule chose à spécifier est le type et l’ordres des variables dans la définition de la fonction

 

Retour sommaire
Chapitre Suivant: Types de Programmes

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