Programmazione D - Sovraccarico

D consente di specificare più di una definizione per un file function nome o un operator nello stesso ambito, che viene chiamato function overloading e operator overloading rispettivamente.

Una dichiarazione sovraccarica è una dichiarazione che era stata dichiarata con lo stesso nome di una dichiarazione precedente nello stesso ambito, tranne per il fatto che entrambe le dichiarazioni hanno argomenti diversi e ovviamente una definizione (implementazione) diversa.

Quando chiami un file overload function o operator, il compilatore determina la definizione più appropriata da utilizzare confrontando i tipi di argomenti utilizzati per chiamare la funzione o l'operatore con i tipi di parametro specificati nelle definizioni. Viene chiamato il processo di selezione della funzione o dell'operatore sovraccaricato più appropriatooverload resolution..

Funzione sovraccarico

È possibile avere più definizioni per lo stesso nome di funzione nello stesso ambito. La definizione della funzione deve differire l'una dall'altra per i tipi e / o il numero di argomenti nell'elenco degli argomenti. Non è possibile eseguire l'overload di dichiarazioni di funzione che differiscono solo per il tipo restituito.

Esempio

L'esempio seguente utilizza la stessa funzione print() per stampare diversi tipi di dati -

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

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

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

Sovraccarico dell'operatore

È possibile ridefinire o sovraccaricare la maggior parte degli operatori incorporati disponibili in D. Pertanto un programmatore può utilizzare anche operatori con tipi definiti dall'utente.

Gli operatori possono essere sovraccaricati utilizzando string op seguito da Add, Sub e così via in base all'operatore che viene sovraccaricato. Possiamo sovraccaricare l'operatore + per aggiungere due caselle come mostrato di seguito.

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'esempio seguente mostra il concetto di sovraccarico di operatori utilizzando una funzione membro. Qui un oggetto viene passato come argomento le cui proprietà sono accessibili utilizzando questo oggetto. È possibile accedere all'oggetto che chiama questo operatore utilizzandothis operatore come spiegato di seguito -

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

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

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

Tipi di sovraccarico dell'operatore

Fondamentalmente, ci sono tre tipi di sovraccarico dell'operatore elencati di seguito.

Sr.No.	Tipi di sovraccarico
1	Sovraccarico di operatori unari
2	Sovraccarico degli operatori binari
3	Overload degli operatori di confronto