Référence MQL5Concepts de Base du LangageFonctionsLa transmission des paramètres

Passer des Paramètres

Il existe deux méthodes grâce auxquelles le langage machine peut passer des arguments à un sous-programme (fonction). La première méthode est d'envoyer un paramètre par valeur. Cette méthode copie la valeur de l'argument dans un paramètre formel de fonction. Tout changement dans ce paramètre dans la fonction n'a donc aucune influence sur l'argument correspondant de l'appel.

//+------------------------------------------------------------------+
//| Passer les paramètres par valeur                                 |
//+------------------------------------------------------------------+
double FirstMethod(int i,int j)
  {
   double res;
//---
   i*=2;
   j/=2;
   res=i+j;
//---
   return(res);
  }
//+------------------------------------------------------------------+
//| Fonction de lancement du programme                               |
//+------------------------------------------------------------------+
void OnStart()
  {
//---
   int a=14,b=8;
   Print("a et b avant l'appel :",a," ",b);
   double d=FirstMethod(a,b);
   Print("a et b après l'appel :",a," ",b);
  }
//--- Résultat de l'exécution du script
//  a et b avant l'appel : 14 8
//  a et b après l'appel : 14 8

La deuxième méthode est de passer par référence. Dans c cas, la référence à un paramètre (et pas sa valeur) est passée au paramètre d'une fonction. Dans la fonction, elle est utilisée pour se référer au paramètre actuel spécifié dans l'appel. Cela signifie qu'un changement du paramètre affectera l'argument utilisé pour appeler la fonction.

//+------------------------------------------------------------------+
//| Passer des paramètres par référence                              |
//+------------------------------------------------------------------+
double SecondMethod(int &i,int &j)
  {
   double res;
//---
   i*=2;
   j/=2;
   res=i+j;
//---
   return(res);
  }
//+------------------------------------------------------------------+
//| Fonction de lancement du programme                               |
//+------------------------------------------------------------------+
void OnStart()
  {
//---
   int a=14,b=8;
   Print("a et b avant l'appel :",a," ",b);
   double d=SecondMethod(a,b);
   Print("a et b après l'appel :",a," ",b);
  }
//+------------------------------------------------------------------+
//--- résultat de l'exécution du script
//  a et b avant l'appel : 14 8
//  a et b après l'appel : 28 4

MQL5 utilise les deux méthodes, avec une exception : les tableaux, les variables de type structure et les objets de classe sont toujours passés par référence. Pour interdire de changer les paramètres courants (les arguments passés à l'appel de la fonction), utilisez le spécificateur d'accès const. En cas de tentative de changer le contenu d'une variable déclarée avec le spécificateur const , le compilateur génèrera une erreur.

Note

Il est à noter que les paramètres sont passés à une fonction dans l'ordre inverse, c'est à dire que le dernier paramètre est d'abord calculé et passé, ensuite l'avant dernier, etc. le dernier paramètre calculé et passé est le premier situé après la parenthèse ouvrante.

Exemple :

void OnStart()
  {
//---
   int a[]={0,1,2};
   int i=0;

   func(a[i],a[i++],"Premier appel (i = "+string(i)+")");
   func(a[i++],a[i],"Deuxième appel (i = "+string(i)+")");
// Résultat :
// Premier appel (i = 0) : par1 = 1     par2 = 0
// Deuxième appel (i = 1) : par1 = 1     par2 = 1

  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void func(int par1,int par2,string comment)
  {
   Print(comment,": par1 = ",par1,"    par2 = ",par2);
  }

Dans le premier appel (voir l'exemple ci-dessus), la variable i est d'abord utilisée dans la concaténation des chaînes de caractères :

"Premier appel (i = "+string(i)+")"

Ici, sa valeur ne change pas. La variable i est ensuite utilisée dans le calcul de l'élément a[i++] du tableau, c'est à dire lors de l'accès à l'élément du tableau avec l'indice i, la i variable est incrémentée. Et seulement après, le premier paramètre avec la valeur changée de la i variable est calculé.

Dans le deuxième appel, la même valeur de i (calculée dans la première phase de l'appel de la fonction) est utilisée lors du calcul des trois paramètres. La variable i n'est encore changée qu'après le calcul du premier paramètre.

Voir aussi

Portée de Visibilité et Durée de Vie des Variables, Surcharge, Fonctions Virtuelles, Polymorphisme

Appel de Fonction

Surcharge de Fonction