Operator overloading in C# allows you to define custom behavior for operators (like +, -, *, etc.) when they are used with instances of your own classes. This can make your classes easier to use and more intuitive. Below are detailed examples of operator overloading in C#.

Example 1: Overloading the Addition Operator

Let's create a simple Vector class that represents a 2D vector and overload the + operator to add two vectors together.

csharp
1using System;
2
3public class Vector
4{
5    public double X { get; }
6    public double Y { get; }
7
8    public Vector(double x, double y)
9    {
10        X = x;
11        Y = y;
12    }
13
14    // Overload the + operator
15    public static Vector operator +(Vector v1, Vector v2)
16    {
17        return new Vector(v1.X + v2.X, v1.Y + v2.Y);
18    }
19
20    public override string ToString()
21    {
22        return $"({X}, {Y})";
23    }
24}
25
26class Program
27{
28    static void Main()
29    {
30        Vector v1 = new Vector(2, 3);
31        Vector v2 = new Vector(4, 5);
32        Vector v3 = v1 + v2; // Calls the overloaded + operator
33        Console.WriteLine(v3); // Output: (6, 8)
34    }
35}

Example 2: Overloading the Subtraction Operator

Continuing with the Vector class, let's overload the - operator to subtract one vector from another.

csharp
1// Overload the - operator
2public static Vector operator -(Vector v1, Vector v2)
3{
4    return new Vector(v1.X - v2.X, v1.Y - v2.Y);
5}
6
7// Usage in the Main method
8Vector v4 = v1 - v2; // Calls the overloaded - operator
9Console.WriteLine(v4); // Output: (-2, -2)

Example 3: Overloading the Multiplication Operator

We can also overload the * operator to scale a vector by a scalar.

csharp
1// Overload the * operator
2public static Vector operator *(Vector v, double scalar)
3{
4    return new Vector(v.X * scalar, v.Y * scalar);
5}
6
7// Usage in the Main method
8Vector v5 = v1 * 2; // Calls the overloaded * operator
9Console.WriteLine(v5); // Output: (4, 6)

Example 4: Overloading the Equality Operator

We can overload the == and != operators to compare two vectors.

csharp
1// Overload the == operator
2public static bool operator ==(Vector v1, Vector v2)
3{
4    return v1.X == v2.X && v1.Y == v2.Y;
5}
6
7// Overload the != operator
8public static bool operator !=(Vector v1, Vector v2)
9{
10    return !(v1 == v2);
11}
12
13// Override Equals and GetHashCode
14public override bool Equals(object obj)
15{
16    if (obj is Vector other)
17    {
18        return this == other; // Calls the overloaded == operator
19    }
20    return false;
21}
22
23public override int GetHashCode()
24{
25    return (X, Y).GetHashCode();
26}
27
28// Usage in the Main method
29Vector v6 = new Vector(2, 3);
30Vector v7 = new Vector(2, 3);
31Console.WriteLine(v6 == v7); // Output: True
32Console.WriteLine(v6 != v7); // Output: False

Example 5: Overloading the Unary Operators

You can also overload unary operators like ++ and --.

csharp
1// Overload the ++ operator
2public static Vector operator ++(Vector v)
3{
4    return new Vector(v.X + 1, v.Y + 1);
5}
6
7// Overload the -- operator
8public static Vector operator --(Vector v)
9{
10    return new Vector(v.X - 1, v.Y - 1);
11}
12
13// Usage in the Main method
14Vector v8 = new Vector(1, 1);
15v8++; // Calls the overloaded ++ operator
16Console.WriteLine(v8); // Output: (2, 2)
17v8--; // Calls the overloaded -- operator
18Console.WriteLine(v8); // Output: (1, 1)

Summary

In this example, we demonstrated how to overload various operators for a custom Vector class. The key points to remember when overloading operators in C# are:

1. Use the static keyword for operator methods.
2. Ensure that the overloaded operators are consistent with the expected mathematical properties.
3. Override Equals and GetHashCode when overloading == and !=.
4. Use the public access modifier to make the operator methods accessible.

Benefits of operator Overloading