Programmation D - Surcharge

D vous permet de spécifier plus d'une définition pour un function nom ou un operator dans la même portée, qui s'appelle function overloading et operator overloading respectivement.

Une déclaration surchargée est une déclaration qui a été déclarée avec le même nom qu'une déclaration précédente dans la même portée, sauf que les deux déclarations ont des arguments différents et une définition évidemment différente (implémentation).

Lorsque vous appelez un surchargé function ou operator, le compilateur détermine la définition la plus appropriée à utiliser en comparant les types d'argument que vous avez utilisés pour appeler la fonction ou l'opérateur avec les types de paramètres spécifiés dans les définitions. Le processus de sélection de la fonction ou de l'opérateur surchargé le plus approprié est appeléoverload resolution..

Surcharge de fonction

Vous pouvez avoir plusieurs définitions pour le même nom de fonction dans la même portée. La définition de la fonction doit différer les unes des autres par les types et / ou le nombre d'arguments dans la liste d'arguments. Vous ne pouvez pas surcharger les déclarations de fonction qui diffèrent uniquement par le type de retour.

Exemple

L'exemple suivant utilise la même fonction print() pour imprimer différents types de données -

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"); 
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

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

Surcharge de l'opérateur

Vous pouvez redéfinir ou surcharger la plupart des opérateurs intégrés disponibles dans D. Ainsi, un programmeur peut également utiliser des opérateurs avec des types définis par l'utilisateur.

Les opérateurs peuvent être surchargés en utilisant la chaîne op suivie de Add, Sub, etc. en fonction de l'opérateur surchargé. Nous pouvons surcharger l'opérateur + pour ajouter deux cases comme indiqué ci-dessous.

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; 
}

L'exemple suivant montre le concept de surcharge d'opérateur à l'aide d'une fonction membre. Ici, un objet est passé comme argument dont les propriétés sont accessibles à l'aide de cet objet. L'objet qui appelle cet opérateur est accessible viathis opérateur comme expliqué ci-dessous -

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);  
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

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

Types de surcharge de l'opérateur

Fondamentalement, il existe trois types de surcharge de l'opérateur, comme indiqué ci-dessous.

N ° Sr.	Types de surcharge
1	Surcharge des opérateurs unaires
2	Surcharge des opérateurs binaires
3	Surcharge des opérateurs de comparaison