C# | Sobrecarga del operador

Requisito previo: Operadores en C#

El concepto de sobrecargar una función también se puede aplicar a los operadores . La sobrecarga de operadores brinda la capacidad de usar el mismo operador para realizar varias operaciones. Proporciona capacidades adicionales a los operadores de C# cuando se aplican a tipos de datos definidos por el usuario. Permite realizar implementaciones definidas por el usuario de varias operaciones donde uno o ambos operandos son de una clase definida por el usuario. Solo el conjunto predefinido de C#los operadores pueden estar sobrecargados. Realizar operaciones en un tipo de datos definido por el usuario no es tan simple como las operaciones en un tipo de datos incorporado. Para utilizar operadores con tipos de datos definidos por el usuario, deben sobrecargarse según los requisitos del programador. Un operador puede sobrecargarse definiéndole una función. La función del operador se declara mediante la palabra clave operator . 

Sintaxis: 

access specifier  className  operator Operator_symbol (parameters)
{
    // Code
}

Nota: la sobrecarga de operadores es básicamente el mecanismo que proporciona un significado especial a un operador de C# ideal con un tipo de datos definido por el usuario, como estructuras o clases.

La siguiente tabla describe la capacidad de sobrecarga de los diversos operadores disponibles en C#:  

 Sobrecarga de operadores unarios

El tipo de retorno puede ser de cualquier tipo excepto void para operadores unarios como !, ~, + y punto (.) pero el tipo de retorno debe ser el tipo de ‘Tipo’ para los operadores – y ++ y debe ser un tipo bool para verdadero así como falsos operadores. Pero recuerde que los operadores verdadero y falso pueden sobrecargarse solo como pares. El error de compilación surge si una clase declara uno de estos operadores sin declarar el otro. 

La siguiente sintaxis muestra el uso del operador unario:  

operator (object); 
here, operator is a symbol that denotes a unary operator. 
operator a; 

Ejemplo :  

Input : 15, -25
Output : -15, 25

Input : -22, 18
Output : 22, -18 

// C# program to illustrate the
// unary operator overloading
using System;
namespace Calculator {
     
class Calculator {
     
    public int number1 , number2;
    public Calculator(int num1 , int num2)
    {
        number1 = num1;
        number2 = num2;
    }
     
// Function to perform operation
// By changing sign of integers
public static Calculator operator -(Calculator c1)
{
    c1.number1 = -c1.number1;
    c1.number2 = -c1.number2;
    return c1;
}
 
// Function to print the numbers
public void Print()
{
    Console.WriteLine ("Number1 = " + number1);
    Console.WriteLine ("Number2 = " + number2);
}
}
 
class EntryPoint
{
     
    // Driver Code
    static void Main(String []args)
    {
         
        // using overloaded - operator
        // with the class object
        Calculator calc = new Calculator(15, -25);
         
        calc = -calc;
         
        // To display the result
        calc.Print();
    }
}
}

Producción : 

Number1 = -15
Number2 = 25

Sobrecarga de operadores binarios

Los operadores binarios trabajarán con dos operandos. Los ejemplos de operadores binarios incluyen los operadores aritméticos (+, -, *, /, %), operadores de asignación aritmética (+=, -+, *=, /+, %=) y operadores relacionales, etc. La sobrecarga de un operador binario es similar sobrecargar un operador unario, excepto que un operador binario requiere un parámetro adicional. 

Sintaxis: 

operator operator (object1, object2); 
Here, second "operator" is a symbol that 
denotes a binary operator. 
operator + (a, b); 

Ejemplo :  

Input : 200, 40
Output : 240

Input : 300, 20 
Output : 320 

// C# program to illustrate the
// Binary Operator Overloading
using System;
namespace BinaryOverload {
     
class Calculator {
     
    public int number = 0;
     
    // no-argument constructor
    public Calculator() {}
     
     
    // parameterized constructor
    public Calculator(int n)
    {
        number = n;
    }
     
    // Overloading of Binary "+" operator
    public static Calculator operator + (Calculator Calc1,
                                         Calculator Calc2)
    {
        Calculator Calc3 = new Calculator(0);
        Calc3.number = Calc2.number + Calc1.number;
        return Calc3;
    }
     
    // function to display result
    public void display()
    {
        Console.WriteLine("{0}", number);
    }
}
 
 
class CalNum {
     
    // Driver Code
    static void Main(string[] args)
    {
         
        Calculator num1 = new Calculator(200);
        Calculator num2 = new Calculator(40);
        Calculator num3 = new Calculator();
         
         
        num3 = num1 + num2;
         
        num1.display(); // Displays 200
         
        num2.display(); // Displays 40
         
        num3.display(); // Displays 240
         
    }
}
}

Producción : 

200
40
240

Beneficios de la sobrecarga del operador: 

• La sobrecarga de operadores proporciona capacidades adicionales a los operadores de C# cuando se aplican a tipos de datos definidos por el usuario.
• Los operadores pueden considerarse funciones internas del compilador.