D Programmierung - Überladen

Mit D können Sie mehr als eine Definition für a angeben function Name oder ein operator im gleichen Umfang, der genannt wird function overloading und operator overloading beziehungsweise.

Eine überladene Deklaration ist eine Deklaration, die mit demselben Namen wie eine vorherige Deklaration im selben Geltungsbereich deklariert wurde, mit der Ausnahme, dass beide Deklarationen unterschiedliche Argumente und offensichtlich unterschiedliche Definitionen (Implementierung) haben.

Wenn Sie einen überlasteten anrufen function oder operatorDer Compiler ermittelt die am besten geeignete Definition, indem er die Argumenttypen, die Sie zum Aufrufen der Funktion oder des Operators verwendet haben, mit den in den Definitionen angegebenen Parametertypen vergleicht. Der Prozess zur Auswahl der am besten geeigneten überlasteten Funktion oder des am besten geeigneten Operators wird aufgerufenoverload resolution..

Funktionsüberladung

Sie können mehrere Definitionen für denselben Funktionsnamen im selben Bereich haben. Die Definition der Funktion muss sich durch die Typen und / oder die Anzahl der Argumente in der Argumentliste unterscheiden. Sie können keine Funktionsdeklarationen überladen, die sich nur nach Rückgabetyp unterscheiden.

Beispiel

Das folgende Beispiel verwendet dieselbe Funktion print() verschiedene Datentypen drucken -

import std.stdio; 
import std.string; 

class printData { 
   public: 
      void print(int i) { 
         writeln("Printing int: ",i); 
      }

      void print(double f) { 
         writeln("Printing float: ",f );
      }

      void print(string s) { 
         writeln("Printing string: ",s); 
      } 
}; 
 
void main() { 
   printData pd = new printData();  
   
   // Call print to print integer 
   pd.print(5);
   
   // Call print to print float 
   pd.print(500.263); 
   
   // Call print to print character 
   pd.print("Hello D"); 
}

Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

Printing int: 5 
Printing float: 500.263 
Printing string: Hello D

Überlastung des Bedieners

Sie können die meisten in D verfügbaren integrierten Operatoren neu definieren oder überladen. Daher kann ein Programmierer auch Operatoren mit benutzerdefinierten Typen verwenden.

Operatoren können mit string op gefolgt von Add, Sub usw. überladen werden, basierend auf dem Operator, der überladen wird. Wir können den Operator + überladen, um zwei Felder hinzuzufügen, wie unten gezeigt.

Box opAdd(Box b) { 
   Box box = new Box(); 
   box.length = this.length + b.length; 
   box.breadth = this.breadth + b.breadth; 
   box.height = this.height + b.height; 
   return box; 
}

Das folgende Beispiel zeigt das Konzept der Operatorüberladung mithilfe einer Elementfunktion. Hier wird ein Objekt als Argument übergeben, auf dessen Eigenschaften mit diesem Objekt zugegriffen wird. Auf das Objekt, das diesen Operator aufruft, kann mit zugegriffen werdenthis Betreiber wie unten erklärt -

import std.stdio;

class Box { 
   public:  
      double getVolume() { 
         return length * breadth * height; 
      }

      void setLength( double len ) { 
         length = len; 
      } 

      void setBreadth( double bre ) { 
         breadth = bre; 
      }

      void setHeight( double hei ) { 
         height = hei; 
      }

      Box opAdd(Box b) { 
         Box box = new Box(); 
         box.length = this.length + b.length; 
         box.breadth = this.breadth + b.breadth; 
         box.height = this.height + b.height; 
         return box; 
      } 

   private: 
      double length;      // Length of a box 
      double breadth;     // Breadth of a box 
      double height;      // Height of a box 
}; 

// Main function for the program 
void main( ) { 
   Box box1 = new Box();    // Declare box1 of type Box 
   Box box2 = new Box();    // Declare box2 of type Box 
   Box box3 = new Box();    // Declare box3 of type Box 
   double volume = 0.0;     // Store the volume of a box here
   
   // box 1 specification 
   box1.setLength(6.0); 
   box1.setBreadth(7.0); 
   box1.setHeight(5.0);
   
   // box 2 specification 
   box2.setLength(12.0); 
   box2.setBreadth(13.0); 
   box2.setHeight(10.0); 
   
   // volume of box 1 
   volume = box1.getVolume(); 
   writeln("Volume of Box1 : ", volume);
   
   // volume of box 2 
   volume = box2.getVolume(); 
   writeln("Volume of Box2 : ", volume); 
   
   // Add two object as follows: 
   box3 = box1 + box2; 
   
   // volume of box 3 
   volume = box3.getVolume(); 
   writeln("Volume of Box3 : ", volume);  
}

Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:

Volume of Box1 : 210 
Volume of Box2 : 1560 
Volume of Box3 : 5400

Überladungsarten für Bediener

Grundsätzlich gibt es drei Arten der Überlastung von Bedienern, wie unten aufgeführt.

Sr.Nr.	Typen überladen
1	Überladen unärer Operatoren
2	Überlastung der Binäroperatoren
3	Vergleich Operatoren überladen