Programación D - Sobrecarga

D le permite especificar más de una definición para un function nombre o un operator en el mismo ámbito, que se llama function overloading y operator overloading respectivamente.

Una declaración sobrecargada es una declaración que ha sido declarada con el mismo nombre que una declaración anterior en el mismo ámbito, excepto que ambas declaraciones tienen argumentos diferentes y, obviamente, una definición (implementación) diferente.

Cuando llamas a un sobrecargado function o operator, el compilador determina la definición más apropiada para usar comparando los tipos de argumentos que usó para llamar a la función u operador con los tipos de parámetros especificados en las definiciones. El proceso de seleccionar la función o el operador sobrecargado más apropiado se llamaoverload resolution..

Sobrecarga de funciones

Puede tener varias definiciones para el mismo nombre de función en el mismo ámbito. La definición de la función debe diferir entre sí por los tipos y / o el número de argumentos en la lista de argumentos. No puede sobrecargar declaraciones de funciones que difieran solo por el tipo de retorno.

Ejemplo

El siguiente ejemplo usa la misma función print() para imprimir diferentes tipos de datos -

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

Cuando se compila y ejecuta el código anterior, produce el siguiente resultado:

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

Sobrecarga del operador

Puede redefinir o sobrecargar la mayoría de los operadores integrados disponibles en D. Por lo tanto, un programador también puede usar operadores con tipos definidos por el usuario.

Los operadores se pueden sobrecargar usando string op seguido de Add, Sub, etc., según el operador que se está sobrecargando. Podemos sobrecargar el operador + para agregar dos cuadros como se muestra a continuación.

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

El siguiente ejemplo muestra el concepto de sobrecarga de operadores utilizando una función miembro. Aquí se pasa un objeto como argumento a cuyas propiedades se accede utilizando este objeto. Se puede acceder al objeto que llama a este operador usandothis operador como se explica a continuación -

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

Cuando se compila y ejecuta el código anterior, produce el siguiente resultado:

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

Tipos de sobrecarga del operador

Básicamente, hay tres tipos de sobrecarga del operador que se enumeran a continuación.

No Señor.	Tipos de sobrecarga
1	Sobrecarga de operadores unarios
2	Sobrecarga de operadores binarios
3	Sobrecarga de operadores de comparación