Operator Overloading in C#

What is Operator Overloading in C#?

Operator Overloading allows developers to define custom behavior for operators when applied to user-defined data types. It enhances code readability and usability by enabling intuitive operations on objects.

Key Features of Operator Overloading

• Allows user-defined types to have operator-like behavior.
• Enhances code readability by using standard arithmetic or logical symbols.
• Requires the operator keyword in a class or struct.
• Only predefined operators can be overloaded (new operators cannot be created).

Example of Operator Overloading

The following example demonstrates how to overload the + operator for a custom class.

Example of Overloading the + Operator:

public class ComplexNumber
{
    public int Real { get; }
    public int Imaginary { get; }

    public ComplexNumber(int real, int imaginary)
    {
        Real = real;
        Imaginary = imaginary;
    }

    // Overloading the + operator
    public static ComplexNumber operator +(ComplexNumber c1, ComplexNumber c2)
    {
        return new ComplexNumber(c1.Real + c2.Real, c1.Imaginary + c2.Imaginary);
    }

    public void Display()
    {
        Console.WriteLine($"{Real} + {Imaginary}i");
    }
}

// Usage
ComplexNumber num1 = new ComplexNumber(2, 3);
ComplexNumber num2 = new ComplexNumber(4, 5);
ComplexNumber result = num1 + num2; // Uses overloaded + operator

result.Display(); // Output: 6 + 8i
        

In this example, the + operator is overloaded to add two complex numbers.

Overloading Comparison Operators

Operators like == and != can be overloaded to compare objects.

Example of Overloading == and != Operators:

public class Point
{
    public int X { get; }
    public int Y { get; }

    public Point(int x, int y)
    {
        X = x;
        Y = y;
    }

    // Overloading == operator
    public static bool operator ==(Point p1, Point p2)
    {
        return p1.X == p2.X && p1.Y == p2.Y;
    }

    // Overloading != operator
    public static bool operator !=(Point p1, Point p2)
    {
        return !(p1 == p2);
    }
}

// Usage
Point p1 = new Point(3, 4);
Point p2 = new Point(3, 4);
Point p3 = new Point(5, 6);

Console.WriteLine(p1 == p2); // Output: True
Console.WriteLine(p1 != p3); // Output: True
        

In this example, the == and != operators are overloaded to compare Point objects.

Rules for Operator Overloading

• Only existing operators can be overloaded; new operators cannot be created.
• Operator overloading must be done inside a class or struct.
• Overloaded operators must be static.
• Certain operators must be overloaded together (e.g., == and !=).

Operator Overloading vs. Method Overloading

Benefits of Operator Overloading

• Enhances code readability by allowing natural arithmetic or logical expressions.
• Improves usability by enabling objects to behave like built-in types.
• Reduces complexity by simplifying operations on objects.
• Makes code more intuitive and easier to maintain.