MetaTrader 5 herunterladen

Parameterübertragung

Es gibt zwei Verfahren, durch die Computersprache das Argument dem Subprogramm (der Funktion) übertragen kann. Das erste Verfahren - Parameterübertragung nach der Bedeutung. Dieses Verfahren kopiert den Wert von Argument in den formellen Funktionsparameter. Darum haben verschiedene Änderungen dieses Paramerters keinen Einfluss auf das entsprechende Aufrufsargument.  

//+------------------------------------------------------------------+
//| Parameterübergabe nach dem Wert                                  |
//+------------------------------------------------------------------+
double FirstMethod(int i,int j)
  {
   double res;
//---
   i*=2;
   j/=2;
   res=i+j;
//---
   return(res);
 ;}
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//---
   int a=14,b=8;
   Print("a und b vor dem Aufruf:",a," ",b);
   double d=FirstMethod(a,b);
   Print("a und b nach dem Aufruf:",a," ",b);
 ;}
//--- Ergebnis der Scriptdurchführung
//  a und b vor dem Aufruf: 14 8
//  a und b nach dem Aufruf: 14 8

Zweites Verfahren - Parameterübertragung durch Referenz. In diesem Fall wird der Verweis auf Parameter (nicht aber auf seine Bedeutung_ dem Funktionsparameter übertragen. Innerhalb der Funktion wird der Verweis verwendet, um zum tatsaechlichen Parameter, angegebenen im Aufruf,  zu greifen. Das bedeutet, dass Parameteränderungen das Argument beeinflussen werden, das für Funktionsaufruf verwendet wurde.

//+------------------------------------------------------------------+
//| Parameterübergabe nach Verweis                                    |
//+------------------------------------------------------------------+
double SecondMethod(int &i,int &j)
  {
   double res;
//---
   i*=2;
   j/=2;
   res=i+j;
//---
   return(res);
 ;}
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//---
   int a=14,b=8;
   Print("a und b vor dem Aufruf:",a," ",b);
   double d=SecondMethod(a,b);
   Print("a und b nach dem Aufruf:",a," ",b);
 ;}
//+------------------------------------------------------------------+
//--- Ergebnis der Scriptdurchführung 
//  a und b vor dem Aufruf: 14 8
//  a und b nach dem Aufruf: 28 4

MQL5 verwendet beide Verfahren, mit Ausnahme von: Felder, Variablen des Typs Strukturen und Klassenobjekte werden immer durch Verweis übertragen. Um Änderungen der tatsaechlichen Parameter auszuschliessen  (Argumente, übertragen beim Funktionsaufruf), muss man Zugriffsspezifikator const verwenden.Beim Versuch, Inhalt der Variable zu verändern, die mit dem Spezifikator const erklärt wurde, generiert der Compiler einen Fehler.

Bemerkung

Es muss behalten werden, dass Parameter der Funktion umgekehrt übertragen werden, d.h. am Anfang wird der letzte Patameter berechnet und übertragen, dann vorletzte usw. Am letzten wird der Parameter berechnet und übertragen, der am ersten nach den Klammern steht.

Beispiel:

void OnStart()
  {
//---
   int a[]={0,1,2};
   int i=0;
 
   func(a[i],a[i++],"Erste Aufruf(i="+string(i)+")");
   func(a[i++],a[i],"Zweiter Aufruf(i="+string(i)+")");
// Ergebnis:
// Erste Aufruf(i=0) : par1 = 1     par2 = 0
// Zweiter Aufruf(i=1) : par1 = 1     par2 = 1
 
 ;}
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void func(int par1,int par2,string comment)
  {
   Print(comment,": par1 =",par1,"    par2 =",par2);
 ;}

 

Beim ersten Aufruf im angeführten Beispiel nimmt die Variable i am Anfang an der Zahlenkonkatenanz teil.

  "Erster Aufruf(i="+string(i)+")"

Dabei verändert sich ihr Wert nicht. Dann beteiligt sich die Variable i an der Berechnung des Elementes vom Feld a[i++], d.h. nach der Entnahme des i-Elementes des Feldes wird die Variable i inkrementiert. Und erst danach wird der erste Parameter mit dem veränderten Wert der Variable i berechnet.

Im zweiten Aufruf bei der Berechnung aller drei Parameter wird derselbe Wert i verwendet, der beim ersten Funktionsaufruf verändert wurde, und erst nach der Berechnung des ersten Parameters verändert sich die Variable i wieder.

Sehen Sie auch

Sichtbereich und Lebensdauer der Variablen, überladen,Virtuelle Funktionen, Polymorphismus