Programação D - Sobrecarga

D permite que você especifique mais de uma definição para um function nome ou um operator no mesmo escopo, que é chamado function overloading e operator overloading respectivamente.

Uma declaração sobrecarregada é uma declaração que foi declarada com o mesmo nome de uma declaração anterior no mesmo escopo, exceto que ambas as declarações têm argumentos diferentes e definição (implementação) obviamente diferente.

Quando você liga para um sobrecarregado function ou operator, o compilador determina a definição mais apropriada a ser usada, comparando os tipos de argumento usados ​​para chamar a função ou operador com os tipos de parâmetro especificados nas definições. O processo de seleção da função ou operador sobrecarregado mais apropriado é chamadooverload resolution..

Sobrecarga de função

Você pode ter várias definições para o mesmo nome de função no mesmo escopo. A definição da função deve diferir uma da outra pelos tipos e / ou número de argumentos na lista de argumentos. Você não pode sobrecarregar as declarações de função que diferem apenas pelo tipo de retorno.

Exemplo

O exemplo a seguir usa a mesma função print() para imprimir diferentes tipos de dados -

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 o código acima é compilado e executado, ele produz o seguinte resultado -

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

Sobrecarga do operador

Você pode redefinir ou sobrecarregar a maioria dos operadores integrados disponíveis em D. Portanto, um programador também pode usar operadores com tipos definidos pelo usuário.

Os operadores podem ser sobrecarregados usando a string op seguida por Add, Sub e assim por diante, com base no operador que está sendo sobrecarregado. Podemos sobrecarregar o operador + para adicionar duas caixas conforme mostrado abaixo.

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

O exemplo a seguir mostra o conceito de sobrecarga de operador usando uma função de membro. Aqui, um objeto é passado como um argumento cujas propriedades são acessadas usando este objeto. O objeto que chama este operador pode ser acessado usandothis operador conforme explicado abaixo -

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 o código acima é compilado e executado, ele produz o seguinte resultado -

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

Tipos de sobrecarga do operador

Basicamente, existem três tipos de sobrecarga do operador, conforme listado abaixo.

Sr. Não.	Tipos de sobrecarga
1	Sobrecarga de operadores unários
2	Sobrecarga de operadores binários
3	Sobrecarga de operadores de comparação