Operator Overloading in C# Language

Operator overloading is a powerful and flexible feature in C# that allows you to define custom behaviors for

operators like +, -, *, and many others. By overloading operators, you can make your C# code more intuitive and expressive. In this post, we’ll explore the concept of operator overloading in C# with examples to illustrate its use.

Why Operator Overloading?

Operator overloading can be particularly useful when working with custom data types. For instance, if you’re working with complex numbers or matrices, operator overloading can make your code more readable and maintainable by allowing you to use familiar arithmetic operators.

Basic Rules for Operator Overloading:

1. You can only overload predefined C# operators, and you cannot create new ones.
2. The operator keyword is used to define an operator method.
3. Operator overloading is done in the class that defines the operands.

Example: Overloading the ‘+’ Operator

using System;

public class Complex
{
    public double Real { get; set; }
    public double Imaginary { get; set; }

    public Complex(double real, double imaginary)
    {
        Real = real;
        Imaginary = imaginary;
    }

    public static Complex operator +(Complex a, Complex b)
    {
        return new Complex(a.Real + b.Real, a.Imaginary + b.Imaginary);
    }

    public override string ToString()
    {
        return $"{Real} + {Imaginary}i";
    }
}

class Program
{
    static void Main()
    {
        Complex num1 = new Complex(3, 2);
        Complex num2 = new Complex(1, 4);
        Complex sum = num1 + num2; // Calls the overloaded + operator
        Console.WriteLine("Sum: " + sum);
    }
}

In this example, we’ve defined a Complex class that represents complex numbers. We overloaded the + operator to add two complex numbers together. The result is a new Complex instance with the sum of the real and imaginary parts.

Example: Overloading the ‘==’ Operator

public static bool operator ==(Complex a, Complex b)
{
    return a.Real == b.Real && a.Imaginary == b.Imaginary;
}

public static bool operator !=(Complex a, Complex b)
{
    return !(a == b);
}

In this example, we overloaded the == and != operators to compare two complex numbers for equality. This allows us to use == and != operators to compare Complex objects directly.