Nachschlagewerk MQL5Grundlagen der SpracheFunktionenÜberladen von Funktionen

Überladung der Funktionen

Gewoehnlich versucht man im Namen der Funktion ihre Hauptbedeutung darzustellen. In der Regel haben lesbare Programme verschiedenartige und gut passende Identifikatoren. Manchmal werden verschiedene Funktionen für dieselbe Zwecke verwendet. Betrachten wir zB die Funktion, die den Durchschnittwert des Feldes von Zahlen mit Doppelgenauigkeit berechnet und dieselbe Funktion, die aber mit Feldern der Ganzzahlen operiert. Sowie Die erste, als auch die zweite benenne wir AverageFromArray:

//+------------------------------------------------------------------+
//| Berechnung des Durchschnittwertes für Feld der Art double        |
//+------------------------------------------------------------------+
double AverageFromArray(const double & array[],int size)
  {
   if(size<=0) return 0.0;
   double sum=0.0;
   double aver;
//---
   for(int i=0;i<size;i++)
     {
      sum+=array[i];    // Addition für double
     }
   aver=sum/size;       // Dividieren wir einfach die Summe durch die Zahl
//---
   Print("Berechnung des Durchschnittwertes für Feld der Art double");
   return aver;
  }
//+------------------------------------------------------------------+
//| Berechnung des Durchschnittwertes für Feld der Art int           |
//+------------------------------------------------------------------+
double AverageFromArray(const int & array[],int size)
  {
   if(size<=0) return 0.0;
   double aver=0.0;
   int sum=0;
//---
   for(int i=0;i<size;i++)
     {
      sum+=array[i];     // Addition für int
     }
   aver=(double)sum/size;// reduzieren wir die Summe zum Typ double und dividieren
//---
   Print("Berechnung des Durchschnittwertes für Feld der Art int");
   return aver;
  }

Jede Funktion hat Nachrichtenausgabe mittels der Funktion Print();

Print("Berechnung des Durchschnittwertes für Feld der Art int");

Compilierer waehlt die notwendige Funktion der Argumententypen und dern Zahl entsprechend. Regel, nach der diese Wahl durchgeführt wird, heisst Algorithmus der Signaturübereinstimmung. Unter Signatur wird die Typenliste verstanden, die in der Funktionserklärung verwendet wird.

Beispiel:

//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//---
   int    a[5]={1,2,3,4,5};
   double b[5]={1.1,2.2,3.3,4.4,5.5};
   double int_aver=AverageFromArray(a,5);
   double double_aver=AverageFromArray(b,5);
   Print("int_aver=",int_aver,"   double_aver=",double_aver);
  }
//--- Ergebnis der Scriptarbeit
// Berecnung des Durchschnittswertes für Feld der Art int
// Berechnung des Durchschnittwertes für Feld der Art double
// int_aver= 3.00000000    double_aver= 3.30000000

überladung ist Zuordnung drr mehreren Werte einer Funktion. Die Auswahl des konkreten Wertes hängt von Argumententypen ab, die die Funktion erhalten hat. Bestimmte Funktion wird abhängig davon ausgewaehlt, ob die Liste der Argumente beim Funktionsaufruf der Liste der Parameter in Funktionserkaerung entspricht oder nicht.

Wenn überladene Funktion aufgerufen wird, muss der Compiler Algorithmus für Auswahl notwendiger Funktion haben. Algorithmus, der diese Wahl trifft, hängt von dem Umwandlungstyp ab. Die beste übereinstimmung muss einzigartig sein. Sie muss am besten für wenigstens ein Argument sein und so gut, wie andere übereinstimmungen für alle anderen Argumente sein.

Unten ist Algorithmus der übereinstimmung für jedes Argument angegeben.

Algorithmus der Wahl von überladener Funktion

strikte übereinstimmung vewenden (wenn es moeglich ist).
Standarderhoehung des Typs probieren.
Standardumwandlung des Typs probieren.

Standarderhoehung des Typs ist besser, als andere Standartumwandlungen. Erhoehung ist Umwandlung von float in double, aber auch von bool, char, short oder enum in int. Außerdem gehört zu Standardumwandlunen Umwandlungen der Felder von aehnlichen Ganzzahliger Typen. Ganzzahlige Typen sind: bool, char, uchar, denn alle drei Typen sind ganzzahlige 1-Byte Typen; 2-Byte ganzzahlige Typen short und ushort; 4-Byte ganzzahlige Typen int, unint und color; long, ulong und datetime.

Bestimmt ist strikte übereinstimmung am besten. Für diese übereinstimmung können Typenreduzierungen verwendet werden. Compilierer wird nicht die doppeldeutige Situation schaffen. Darum soll man nicht auf feine Unterschiede unter Typen und explizite Umwandlungen Wert legen, die gestaute Funktion unklar machen.

Wenn Sie zweifeln, verwenden Sie explizite Umwandlungen, um strikte übereinstimmung zu gewaehrleisten.

Beispiele überladener Funktionen in MQL5 können Sie am Beispiel der Funktionen ArrayInitialize() beobachten.

überladungsregeln der Funktion ist für überladung der Klassenmethoden anwendbar.

überladen der Sysemfunktionen ist zulaessig, dabei muss man verfolgen, dass Compiler die noetige Funktion genau waehlen kann. ZB können wir Systemfunktion fmax() mittels der drei vershiedenen Verfahren stauen, aber nur zwei von ihnen werden korrekt sein.

Beispiel:

// Stauung ist zulaessig - unterscheidet sich nach der Zahl der Parameter
double fmax(double a,double b,double c);

// Stauung mit Fehler
// Parameterzahl ist verschieden, aber der letzte hat Default-Wert
// das führt zum Kapseln der Systemfunktion beim Aufruf, was unzulaessug ist
double fmax(double a,double b,double c=DBL_MIN);

// normale überladung nach der Parameterzahl
int fmax(int a,int b);

Sehen Sie auch

überladen,Virtuelle Funktionen, Polymorphismus

Parameteruebertragung

Überladen von Operatoren